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;

typedef pair<int,int> ii;
typedef pair<int, ii> II;
const int N = 200005;

int n, a[N], p[N];
ii pmin[2][N][18];
int lg[N];
priority_queue < II, vector<II>, greater<II> > seg;
bool del[N];

ii get(ii a[][18], int l, int r) {
	int k = lg[r - l + 1];
	return min(a[l][k], a[r - (1 << k) + 1][k]);
}

void add(int l, int r) {
	if (l >= r) return;
	int val = get(pmin[l % 2], l / 2, (r - 1) / 2).first;
	seg.push(II(val, ii(l, r)));
}

void solve(int l, int r, int pos) {
	// to the right: [pos + 1, r]
	int newr = get(pmin[r % 2], (pos + 1) / 2, r / 2).second;
	printf("%d %d ", a[pos], a[newr]);
	del[pos] = del[newr] = true;

	add(l, pos - 1);
	add(pos + 1, newr - 1);
	add(newr + 1, r);
}

int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; ++i) scanf("%d", a + i), p[a[i]] = i;

	// prepare
	for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;

	for (int i = 0; i < n; ++i) {
		pmin[i % 2][i / 2][0] = make_pair(a[i], i);
	}

	for (int j = 1; j <= 17; ++j) {
		for (int i = 0; i + (1 << j) - 1 < n / 2; ++i) {
			for (int parity = 0; parity <= 1; ++parity) {
				pmin[parity][i][j] = min(pmin[parity][i][j - 1], pmin[parity][i + (1 << j - 1)][j - 1]);
			}
		}
	}

	// solve
	add(0, n - 1);

	while(!seg.empty()) {
		II top = seg.top(); seg.pop();
		int l = top.second.first, r = top.second.second, pos = p[top.first];
		solve(l, r, pos);
	}
}