Let N be a positive even number.

We have a permutation of (1, 2, ..., N), p = (p_1, p_2, ..., p_N). Snuke is constructing another permutation of (1, 2, ..., N), q, following the procedure below.

First, let q be an empty sequence. Then, perform the following operation until p becomes empty:

* Select two adjacent elements in p, and call them x and y in order. Remove x and y from p (reducing the length of p by 2), and insert x and y, preserving the original order, at the beginning of q.



When p becomes empty, q will be a permutation of (1, 2, ..., N).

Find the lexicographically smallest permutation that can be obtained as q.

Constraints

* N is an even number.
* 2 ≤ N ≤ 2 × 10^5
* p is a permutation of (1, 2, ..., N).

Input

Input is given from Standard Input in the following format:


N
p_1 p_2 ... p_N


Output

Print the lexicographically smallest permutation, with spaces in between.

Examples

Input

4
3 2 4 1


Output

3 1 2 4


Input

2
1 2


Output

1 2


Input

8
4 6 3 2 8 5 7 1


Output

3 1 2 7 4 6 8 5
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;

int n , a[N] , LOG[N] , f[2][18][N] , pos[N];

int rmq(int k , int l , int r) {
    //cout << k << ' ' << l << ' ' << r << endl;
    int j = LOG[r - l + 1];
    return min(f[k][j][l] , f[k][j][r - (1 << j) + 1]);
}

pair<int , int> cal(int l , int r) {
    int x = rmq(l & 1 , l , r);
    int y = rmq((pos[x] + 1) & 1 , pos[x] + 1 , r);
    //cout << x << ' ' << y << endl;
    return {-x , -y};
}

int main() {
    scanf("%d" , &n);
    for (int i = 0 ; i < n ; ++ i) {
        scanf("%d" , &a[i]);
        pos[a[i]] = i;
    }
    for (int i = 2 ; i <= n ; ++ i) {
        LOG[i] = LOG[i >> 1] + 1;
    }
    for (int l = 0 ; l < 2 ; ++ l) {
        for (int i = 0 ; i < n ; ++ i) {
            f[l][0][i] = (i % 2 == l) ? a[i] : 1 << 30;
        }
        for (int k = 1 ; 1 << k <= n ; ++ k) {
            for (int j = 0 ; j + (1 << k) - 1 < n ; ++ j) {
                f[l][k][j] = min(f[l][k - 1][j] , f[l][k - 1][j + (1 << k - 1)]);
            }
        }
    }
    priority_queue< pair< pair<int , int> , pair<int , int> > > Q;
    Q.push({ cal(0 , n - 1) , {0 , n - 1}});
    while (!Q.empty()) {
        auto it = Q.top(); Q.pop();
        int x = -it.first.first;
        int y = -it.first.second;
        printf("%d %d " , x , y);
        int l = it.second.first;
        int r = it.second.second;
        x = pos[x] , y = pos[y];
        if (l < x - 1) {
            Q.push({ cal(l , x - 1) , {l , x - 1}});
        }
        if (x + 1 < y - 1) {
            Q.push({ cal(x + 1 , y - 1) , {x + 1 , y - 1}});
        }
        if (y + 1 < r) {
            Q.push({ cal(y + 1 , r) , {y + 1 , r}});
        }
    }
    puts("");
}
