//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,avx512f")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <iostream>
#include <iomanip>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <stack>
#include <queue>
#include <bitset>
#include <numeric>
#include <cassert>
#include <memory>
#include <random>
#include <functional>
#include <complex>
#include <immintrin.h>
#include <stdexcept>
#ifdef DEBUG
#include "./CompetitiveProgrammingCpp/debug.hpp"
#include "./CompetitiveProgrammingCpp/Timer.hpp"
#include "./CompetitiveProgrammingCpp/sample.hpp"
#else
#define dump(...)
template<class T>constexpr inline auto d_val(T a, T b) { return a; }
#endif

/* macro */
#define FOR(i, b, e) for(ll i = (ll)(b); i < (ll)(e); ++i)
#define RFOR(i, b, e) for(ll i = (ll)((e)-1); i >= (ll)(b); --i)
#define REP(i, n) FOR(i, 0, (n))
#define RREP(i, n) RFOR(i, 0, (n))
#define REPC(x,c) for(const auto& x:(c))
#define REPI2(it,b,e) for(auto it = (b); it != (e); ++it)
#define REPI(it,c) REPI2(it, (c).begin(), (c).end())
#define RREPI(it,c) REPI2(it, (c).rbegin(), (c).rend())
#define REPI_ERACE2(it, b, e) for(auto it = (b); it != (e);)
#define REPI_ERACE(it, c) REPI_ERACE2(it, (c).begin(), (c).end())
#define ALL(x) (x).begin(),(x).end()
#define cauto const auto&
/* macro func */
template<class T>
inline auto sort(T& t) { std::sort(ALL(t)); }
template<class T>
inline auto rsort(T& t) { std::sort((t).rbegin(), (t).rend()); }
template<class T>
inline auto unique(T& t) { (t).erase(unique((t).begin(), (t).end()), (t).end()); }
template<class T, class S>
inline auto chmax(T& t, const S& s) { if(s > t) { t = s; return true; } return false; }
template<class T, class S>
inline auto chmin(T& t, const S& s) { if(s < t) { t = s; return true; } return false; }
inline auto BR() { std::cout << "\n"; }

/* type define */
using ll = long long;
using VS = std::vector<std::string>;
using VL = std::vector<long long>;
using VVL = std::vector<VL>;
using VVVL = std::vector<VVL>;
using VVVVL = std::vector<VVVL>;
using VVVVVL = std::vector<VVVVL>;
using VD = std::vector<double>;
template<class T>
using V = std::vector<T>;
template<class T = ll, class U = T>
using P = std::pair<T, U>;
using PAIR = P<ll>;

/* using std */
using std::cout;
constexpr char endl = '\n';
using std::cin;
using std::pair;
using std::string;
using std::stack;
using std::queue;
using std::deque;
using std::vector;
using std::list;
using std::map;
using std::unordered_map;
using std::multimap;
using std::unordered_multimap;
using std::set;
using std::unordered_set;
using std::unordered_multiset;
using std::multiset;
using std::bitset;
using std::priority_queue;

/* Initial processing  */
struct Preprocessing { Preprocessing() { std::cin.tie(0); std::ios::sync_with_stdio(0); }; }_Preprocessing;

/* Remove the source of the bug */
auto pow(signed, signed) { assert(false); }

/* define hash */
namespace std {
template <>	class hash<std::pair<ll, ll>> { public:	size_t operator()(const std::pair<ll, ll>& x) const { return hash<ll>()(1000000000 * x.first + x.second); } };
}

/* input */
template<class T> std::istream& operator >> (std::istream& is, vector<T>& vec) { for(T& x : vec) is >> x; return is; }

/* constant value */
constexpr ll MOD = 1000000007;
// constexpr ll MOD = 998244353;

//=============================================================================================

template<class T>
class isMonoid {
    template <class U>
    static auto check(U x) -> decltype(x.binaryOperation(x), std::true_type{});
    static std::false_type check(...);
public:
    static bool const value = decltype(check(std::declval<T>()))::value;
};

template<
    class Monoid, class MonoidOp, class op,
    std::enable_if_t<isMonoid<Monoid>::value, std::nullptr_t> = nullptr,
    std::enable_if_t<isMonoid<MonoidOp>::value, std::nullptr_t> = nullptr>
class LazySegmentTree {
private:

    const int m_size;
    std::vector<Monoid> m_node;
    std::vector<MonoidOp> m_lazy;
    using S = decltype(Monoid().m_val);

    int calcSize(int n) const { int size = 1; while(size < n) { size <<= 1; }return size; }

    auto _lazy_update(int i, const MonoidOp& val) {
        if(i >= (m_size << 1) - 1) { return; }
        m_lazy[i] = m_lazy[i].binaryOperation(val);
    }

    auto _propagate(int i) {
        m_node[i] = op()(m_node[i], m_lazy[i]);
        _lazy_update((i << 1) + 1, m_lazy[i]);
        _lazy_update((i << 1) + 2, m_lazy[i]);
        m_lazy[i] = MonoidOp();
    }

    auto _update(int l, int r, int k, int nl, int nr, const MonoidOp& m) {
        _propagate(k);
        if(nr < l || r < nl) { return; }
        if(l <= nl && nr <= r) { _lazy_update(k, m); _propagate(k); return; }
        _update(l, r, (k << 1) + 1, nl, (nl + nr) >> 1, m);
        _update(l, r, (k << 1) + 2, ((nl + nr) >> 1) + 1, nr, m);
        m_node[k] = m_node[(k << 1) + 1].binaryOperation(m_node[(k << 1) + 2]);
    }

    auto _query(int l, int r, int k, int nl, int nr) {
        _propagate(k);
        if(nr < l || r < nl) { return Monoid(); }
        if(l <= nl && nr <= r) { return m_node[k]; }
        auto l_val = _query(l, r, (k << 1) + 1, nl, (nl + nr) >> 1);
        auto r_val = _query(l, r, (k << 1) + 2, ((nl + nr) >> 1) + 1, nr);
        return l_val.binaryOperation(r_val);
    }

    auto _construct(const std::vector<S>& vec) {
        for(unsigned int i = 0; i < vec.size(); ++i) {
            m_node[i + m_size - 1] = Monoid(vec[i]);
        }
        for(int i = m_size - 2; i >= 0; --i) {
            m_node[i] = m_node[(i << 1) | 1].binaryOperation(m_node[(i + 1) << 1LL]);
        }
    }
public:
    LazySegmentTree(int n) : m_size(calcSize(n)), m_node((m_size << 1) - 1), m_lazy((m_size << 1) - 1) {}
    LazySegmentTree(int n, const std::vector<S>& vec) :LazySegmentTree(n) { _construct(vec); }

    auto update(int l, int r, const MonoidOp& val) {
        _update(l, r, 0, 0, m_size - 1, val);
    }

    auto query(int l, int r) {
        return _query(l, r, 0, 0, m_size - 1).m_val;
    }

    auto output() {
        for(int i = 0; i < (m_size << 1) - 1; ++i) { _propagate(i); }
        for(int i = 0; i < m_size; ++i) { std::cout << m_node[m_size + i - 1] << " "; }
        std::cout << std::endl;
    }

};

template<
    class S,   // 要素の型
    S& element, // 元
    class T // 2項演算のFunctor
>
struct Monoid {
    S m_val;
    Monoid() :m_val(element) {}
    Monoid(S val) :m_val(val) {}
    Monoid  binaryOperation(const Monoid& m2)const { return T()(m_val, m2.m_val); }
    friend std::ostream& operator<<(std::ostream& os, const Monoid<S, element, T>& m) {
        return os << m.m_val;
    }
};

ll base_m{static_cast<ll>(1e18)};
struct F_RMQ {
    auto operator()(ll a, ll b)const {
        return std::min(a, b);
    }
};
using M_M = Monoid<ll, base_m, F_RMQ>;

ll base_u{static_cast<ll>(-1e18)};
struct F_RUQ {
    auto operator()(ll a, ll b)const {
        if(b == base_u) { return a; }
        return b;
    }
};
using M_U = Monoid<ll, base_u, F_RUQ>;



struct OP_RUQ_RMQ {
    auto operator()(const M_M& m, const M_U& m2) {
        if(m2.m_val == base_u) { return m; }
        return M_M(m2.m_val);
    }
};
signed main() {

    ll n;
    cin >> n;
    VL a(n);
    cin >> a;

    map<ll, PAIR> mp;
    REP(i, n) {
        if(mp.find(a[i]) == mp.end()) {
            mp.emplace(a[i], PAIR{i,i});
        } else {
            chmin(mp[a[i]].first, i);
            chmax(mp[a[i]].second, i);
        }
    }

    auto segtree = LazySegmentTree<M_M, M_U, OP_RUQ_RMQ>(n, a);
    for(const auto& [x, p] : mp) {
        auto [l, r] = p;
        segtree.update(l, r, x);
    }

    REP(i, n) {
        cout << segtree.query(i, i) << " ";
    }BR();


}