#include <bits/stdc++.h>

typedef long long ll;
typedef unsigned long long ull;

#define FOR(i,a,b) for(int (i)=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define RANGE(vec) (vec).begin(),(vec).end()

using namespace std;
template <typename T>
struct LazySegTree {
    std::vector<T> seg;         // 区間の総和
    std::vector<T> lazy;        // 遅延評価用
    int bottomSize;
    int calcBottomSize(int n)
    {
        int size = 1;
        while (size < n) size *= 2;
        return bottomSize=size;
    }
    void init(int n)
    {
        int sz = calcBottomSize(n);
        seg.resize(sz*2,0);
        lazy.resize(sz*2,-1);
    }
    LazySegTree(int n)
    {
        init(n);
    }
    void push(int k, int l, int r)
    {
        if (lazy[k] != -1)
        {
            seg[k] = lazy[k] * (r-l);
            if (r - l > 1)
            {
                lazy[k*2+1] = lazy[k];
                lazy[k*2+2] = lazy[k];
            }
            lazy[k] = -1;
        }
    }
    T merge(T x, T y) { return x + y; }
    void update(int a, int b, T v,
                int k, int l, int r)
    {
        push(k,l,r);
        if (r <= a || b <= l)
            return;
        if (a <= l && r <= b)
        {
            lazy[k] = v;
            push(k,l,r);
        }
        else
        {
            update(a,b,v,k*2+1,l,(l+r)/2);
            update(a,b,v,k*2+2,(l+r)/2,r);
            seg[k] = merge(seg[k*2+1],seg[k*2+2]);
        }
    }
    // 区間 [a,b) を v で塗りつぶす
    void update(int a, int b, T v)
    {
        update(a,b,v,0,0,bottomSize);
    }
    T query(int a, int b, int k, int l, int r)
    {
        push(k,l,r);
        if (r <= a || b <= l)
            return 0;
        if (a <= l && r <= b)
            return seg[k];
        T x = query(a,b,k*2+1,l,(l+r)/2);
        T y = query(a,b,k*2+2,(l+r)/2,r);
        return merge(x,y);
    }
    // 区間 [a,b) の総和を求める
    T query(int a, int b)
    {
        return query(a,b,0,0,bottomSize);
    }

};
class GakuX5
{
public:
    void solve(void)
    {
        int n;
        cin>>n;

        //
        // bi が t に置き換えられるのは bi の左右に t が存在するときなので
        // bi = max{t| l<=i<=r && t == a[l] == a[r]}
        //       t
        //
        vector<ll> a(n);
        map<ll,int> first;
        map<ll,int> last;
        LazySegTree<ll> seg(n);

        REP(i,n)
        {
            cin>>a[i];
            last[a[i]] = i;
            if (first.count(a[i]) == 0)
                first[a[i]] = i;
            seg.update(i,i+1,a[i]);
        }

        for (auto kv : first)
        {
            ll  v;
            int fst;
            tie(v,fst) = kv;

            // 対になっているものだけ update
            if (last.count(v) == 0)
                continue;
            seg.update(fst,last[v]+1,v);
        }
        REP(i,n)
        {
            cout<<seg.query(i,i+1);
            if (i != n-1)
                cout<<" ";
        }
        cout<<endl;
    }
};

#if 1
int main(int argc, char *argv[])
{
        ios::sync_with_stdio(false);
        auto obj = new GakuX5();
        obj->solve();
        delete obj;
        return 0;
}
#endif