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
#define FILEIO(a) freopen(a".in", "r", stdin); freopen(a".out", "w", stdout);
#include <cstdio>
#include <queue>

const int N = 200005, M = 17;

int n, A[N];

int lg[N], st[M][N];

inline int pmin(int a, int b) {
	return A[a] < A[b] ? a : b;
}
void init() {
	for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
	for (int i = 1; i <= 2 * n; ++i) st[0][i] = i;
	for (int j = 0; j < lg[n]; ++j) {
		for (int i = (4 << j) - 1; i <= 2 * n; ++i) {
			st[j + 1][i] = pmin(st[j][i - (2 << j)], st[j][i]);
		}
	}
}
inline int query(int l, int r) {
	int k = lg[(r - l) / 2 + 1];
	return pmin(st[k][l + (2 << k) - 2], st[k][r]);
}

struct node {
	int l, r, u;
	node(int l, int r): l(l), r(r), u(query(l, r - 1)) {}
	inline bool operator<(const node &b) const {
		return A[u] > A[b.u];
	}
};

int main() {
//	FILEIO("seq")
	scanf("%d", &n); n /= 2;
	for (int i = 1; i <= 2 * n; ++i) scanf("%d", A + i);
	init();
	std::priority_queue<node> q;
	q.push(node(1, 2 * n));
	while (!q.empty()) {
		node cur = q.top(); q.pop();
		int v = query(cur.u + 1, cur.r);
		printf("%d %d ", A[cur.u], A[v]);
		if (cur.u != cur.l) q.push(node(cur.l, cur.u - 1));
		if (v != cur.r) q.push(node(v + 1, cur.r));
		if (cur.u + 1 != v) q.push(node(cur.u + 1, v - 1));
	}
	puts("");
	return 0;
}