Problem:
Score : 800 points

Problem Statement

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.

Sample Input 1

4
3 2 4 1

Sample Output 1

3 1 2 4

The solution above is obtained as follows:

p

q

(3, 2, 4, 1)

()

↓

↓

(3, 1)

(2, 4)

↓

↓

()

(3, 1, 2, 4)

Sample Input 2

2
1 2

Sample Output 2

1 2

Sample Input 3

8
4 6 3 2 8 5 7 1

Sample Output 3

3 1 2 7 4 6 8 5

The solution above is obtained as follows:

p

q

(4, 6, 3, 2, 8, 5, 7, 1)

()

↓

↓

(4, 6, 3, 2, 7, 1)

(8, 5)

↓

↓

(3, 2, 7, 1)

(4, 6, 8, 5)

↓

↓

(3, 1)

(2, 7, 4, 6, 8, 5)

↓

↓

()

(3, 1, 2, 7, 4, 6, 8, 5)

Solution in C++14 (GCC 5.4.1) (judge verdict: Runtime Error)

#include <iostream>
#include <queue>
#include <utility>
using namespace std;

int N;
int p[200000+5];
int idx[200000+5];

int main()
{
    cin >> N;
    for (int i = 0; i < N; ++i) {
        cin >> p[i];
        idx[p[i]-1] = i;
    }
    vector<int> right(N+1, -N);
    vector<int> left(N+1, -N);
    auto cmp = [](const pair<int, int>& a, const pair<int, int>& b) {
        return a.first + a.second < b.first + b.second;
    };
    priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> max_heap(cmp);

    for (int i = 0; i < N-1; ++i) {
        right[p[i]] = p[i+1];
        left[p[i+1]] = p[i];
        max_heap.emplace(p[i], p[i+1]);
    }

    vector<int> used(N+1, false);
    vector<int> ans(N);
    int NN = N/2;
    for (int i = 0; i < NN; ++i) {
        int a, b;
        do {
            auto& top = max_heap.top();
            a = top.first;
            b = top.second;
            max_heap.pop();
        } while (used[a] || used[b]);

        used[a] = true;
        used[b] = true;
        int idx = (NN-i-1)*2;
        ans[idx] = a;
        ans[idx+1] = b;
        int a_left = left[a];
        int b_right = right[b];
        right[a_left] = b_right;
        left[b_right] = a_left;
        max_heap.emplace(a_left, b_right);
    }

    cout << ans[0];
    for (int i = 1; i < N; ++i) {
        cout << ' ' << ans[i];
    }
    return 0;
}