#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template<typename T> void chmin(T &a, const T &b) { a = min(a, b); }
template<typename T> void chmax(T &a, const T &b) { a = max(a, b); }
struct FastIO {FastIO() { cin.tie(0); ios::sync_with_stdio(0); }}fastiofastio;
#ifdef DEBUG_ 
#include "../program_contest_library/memo/dump.hpp"
#else
#define dump(...)
#endif
const ll INF = 1LL<<60;

template <typename Monoid>
struct lazysegtree {
    using T = typename Monoid::T;
    using E = typename Monoid::E;
    int n, height;
    vector<T> dat;
    vector<E> lazy;

    lazysegtree() {}
    lazysegtree(int n_) {
        n = 1, height = 0;
        while(n <= n_) { n *= 2; height++; }
        dat.assign(n*2, Monoid::dt());
        lazy.assign(n*2, Monoid::de());
    }
    void build(vector<T> v) {
        REP(i, v.size()) dat[i+n] = v[i];
        for(int i=n-1; i>0; --i) dat[i] = Monoid::f(dat[i*2], dat[i*2+1]);
    }

    inline T reflect(int k) { return lazy[k]==Monoid::de()?dat[k]:Monoid::g(dat[k], lazy[k]); }
    inline void eval(int k) {
        if(lazy[k] == Monoid::de()) return;
        lazy[2*k]   = Monoid::h(lazy[k*2],   lazy[k]);
        lazy[2*k+1] = Monoid::h(lazy[k*2+1], lazy[k]);
        dat[k] = reflect(k);
        lazy[k] = Monoid::de();
    }
    inline void thrust(int k) { for(int i=height;i;--i) eval(k>>i); }
    inline void recalc(int k) { while(k>>=1) dat[k] = Monoid::f(reflect(k*2), reflect(k*2+1)); }

    void update(int a, int b, E x) {
        thrust(a+=n);
        thrust(b+=n-1);
        for(int l=a, r=b+1; l<r; l>>=1,r>>=1) {
            if(l&1) lazy[l] = Monoid::h(lazy[l], x), ++l;
            if(r&1) --r, lazy[r] = Monoid::h(lazy[r], x);
        }
        recalc(a);
        recalc(b);
    }
    T query(int a, int b) {
        thrust(a+=n);
        thrust(b+=n-1);
        T vl=Monoid::dt(), vr=Monoid::dt();
        for(int l=a, r=b+1; l<r; l>>=1,r>>=1) {
            if(l&1) vl=Monoid::f(vl, reflect(l++));
            if(r&1) vr=Monoid::f(reflect(--r), vr);
        }
        return Monoid::f(vl, vr);
    }

    friend ostream &operator <<(ostream& out,const lazysegtree<Monoid>& seg) {
        out << "---------------------" << endl;
        int cnt = 1;
        for(int i=1; i<=seg.n; i*=2) {
            REP(j, i) {
                out << "(" << seg.dat[cnt] << "," << seg.lazy[cnt] << ") ";
                cnt++;
            }
            out << endl;
        }
        out << "---------------------" << endl;
        return out;
    }
};

struct update_min {
    using T = pair<PII,ll>;
    using E = ll;
    static T dt() { return T({{INF, INF}, 0}); }
    static constexpr E de() { return INF; }
    static T f(const T &a, const T &b) {
        T ret;
        if(a.first.first < b.first.first) {
            ret.first.first = a.first.first;
            ret.first.second = a.first.second;
        } else {
            ret.first.first = b.first.first;
            ret.first.second = b.first.second;
        }
        ret.second = a.second+b.second;
        return ret;
    }
    static T g(const T &a, const E &b) {
        T ret;
        ret.first.first = b;
        ret.first.second = a.first.second;
        ret.second = a.second;
        return ret;
    }
    static E h(const E &a, const E &b) {
        return b == de() ? a : b;
    }
};

int main(void) {
    ll n;
    cin >> n;
    vector<ll> p(n);
    REP(i, n) cin >> p[i];

    lazysegtree<update_min> gu(n), ki(n);
    vector<pair<PII,ll>> init_g(n), init_k(n);
    REP(i, n) {
        if(i%2==0) {
            init_g[i] = {{p[i], i}, 1};
            init_k[i] = {{INF, i}, 1};
        } else {
            init_g[i] = {{INF, i}, 1};
            init_k[i] = {{p[i], i}, 1};
        }
    }
    gu.build(init_g);
    ki.build(init_k);

    vector<ll> ans;
    using P = pair<ll,PII>;
    priority_queue<P, vector<P>, greater<P>> que;
    que.push({0, {0, n}});
    while(que.size()) {
        ll l, r;
        tie(l, r) = que.top().second; que.pop();
        // [l, r) の偶数番目
        PII a = (l%2==0 ? gu : ki).query(l, r).first;
        ans.push_back(a.first);
        ll idx1 = a.second; 
        // [idx+1, r) の奇数番目
        PII b = (l%2==0 ? ki : gu).query(idx1+1, r).first;
        ans.push_back(b.first);
        ll idx2 = b.second;

        // [l, idx1) [idx1+1, idx2) [idx2+1, r)
        if(l < idx1) que.push({(l%2==0 ? gu : ki).query(l, idx1).first.first, {l, idx1}});
        if(idx1+1 < idx2) que.push({((idx1+1)%2==0 ? gu : ki).query(idx1+1, idx2).first.first, {idx1+1, idx2}});
        if(idx2+1 < r) que.push({((idx2+1)%2==0 ? gu : ki).query(idx2+1, r).first.first, {idx2+1, r}});
    }

    REP(i, n) cout << ans[i] << (i==n-1 ? '\n' : ' ');
    cout << flush;

    return 0;
}

Measured memory_bytes: 50480