Mike is the president of country What-The-Fatherland. There are *n* bears living in this country besides Mike. All of them are standing in a line and they are numbered from 1 to *n* from left to right. *i*-th bear is exactly *a*<sub class="lower-index">*i*</sub> feet high. 

A group of bears is a non-empty contiguous segment of the line. The size of a group is the number of bears in that group. The strength of a group is the minimum height of the bear in that group.

Mike is a curious to know for each *x* such that 1 ≤ *x* ≤ *n* the maximum strength among all groups of size *x*.
The first line of input contains integer *n* (1 ≤ *n* ≤ 2 × 10<sup class="upper-index">5</sup>), the number of bears.

The second line contains *n* integers separated by space, *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>), heights of bears.
try:
        import sys
        from functools import lru_cache, cmp_to_key
        from heapq import merge, heapify, heappop, heappush
        # from math import *
        from collections import defaultdict as dd, deque, Counter as C
        from itertools import combinations as comb, permutations as perm
        from bisect import bisect_left as bl, bisect_right as br, bisect, insort
        from time import perf_counter
        from fractions import Fraction
        import copy
        from copy import deepcopy
        import time
        starttime = time.time()
        mod = int(pow(10, 9) + 7)
        mod2 = 998244353

        def data(): return sys.stdin.readline().strip()
        def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
        def L(): return list(sp())
        def sl(): return list(ssp())
        def sp(): return map(int, data().split())
        def ssp(): return map(str, data().split())
        def l1d(n, val=0): return [val for i in range(n)]
        def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
        def A2(n,m): return [[0]*m for i in range(n)]
        def A(n):return [0]*n
        # input = stdin.buffer.readline
        # I = lambda : list(map(int,input().split()))
        # import sys
        # input=sys.stdin.readline
        

        sys.stdin = open("input.txt", "r")
        sys.stdout = open("output.txt", "w")
except:
        pass

n = L()[0]
 
A = L()
MINIMUM = min(A)
rank = {}
invrank = {}
for i,v in enumerate(sorted(A)):
        rank[v] = i + 1 
        
for ele in rank:
        invrank[rank[ele]]=ele


A = [rank[ele] for ele in A]
 
 
 
BIT = [0 for i in range(n+10)]
 
def update(i):
        while i <= n:
                BIT[i] += 1
                i += i&(-i)
 
def get_sum(i):
        s = 0
        while(i):
                s += BIT[i]
                i -= i&(-i)
        return s


d = {}

for i,ele in enumerate(A):
        x = get_sum(ele-1)
        if invrank[ele] not in d:
                d[invrank[ele]]={}
        if x not in d[invrank[ele]]:
                d[invrank[ele]][x] = [i,i]
        d[invrank[ele]][x][1]=i
        update(ele)

ans = [0 for i in range(n+1)]
ans[n-1] = MINIMUM
for ele in d:
        for x in d[ele]:
                i,j = d[ele][x]
                dist = j-i
                ans[dist] = max(ans[dist],ele)

for i in range(n-1,-1,-1):
        ans[i] = max(ans[i],ans[i+1])
print(*ans[:-1])