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 <iostream>
#include <cstdio>
#include <queue>
#define N 200005
using namespace std;

int n, a[N], d[N][20];
struct st {
	int x, y, l, r;
};

bool operator < (st p, st q) {
	return a[p.x] > a[q.x];
}
priority_queue<st> qu;
int mn(int p, int q) {return a[p] < a[q] ? p : q;}

void f(int p, int q) {
	int i, t1, t2;
	if (q - p <= 0) return;
	if (q - p == 1) {
		qu.push({p, q, p, q});
		return;
	}
	for (i = 1; 1<<i <= q-p+1; i++);
	i--;
	t1 = mn(d[p][i], d[q - (1 << i) + 1][i]);
	if (q - t1 == 1) {
		qu.push({t1, q, p, q});
		return;
	}
	for (i = 1; 1<<i <= q-t1; i++);
	i--;
	t2 = mn(d[t1 + 1][i], d[q - (1 << i) + 2][i]);
	qu.push({t1, t2, p, q});
}
int main()
{
	int i, j, k;
	st t;
	cin >> n;
	for (i = 0; i < n; i++) {
		scanf ("%d", &a[i]);
		d[i][1] = i;
	}
	for (j = 2; 1<<j <= n; j++) {
		k = 1<<(j-1);
		for (i = 0; i + k < n; i++) {
			d[i][j] = mn(d[i][j - 1], d[i + k][j - 1]);
		}
	}
	f(0, n - 1);
//	f(0, 1);
//	f(0, 3);
	while (!qu.empty()) {
		t = qu.top(); qu.pop();
		printf("%d %d ", a[t.x], a[t.y]);
		f(t.l, t.x -1);
		f(t.x + 1, t.y - 1);
		f(t.y + 1, t.r);
	}
    return 0;
}
