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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Main main = new Main();
		main.solveE();
	}

	class Pair {
		int left;
		int right;
		Pair prev;
		Pair next;

		public Pair(int left, int right, Pair prev) {
			this.left = left;
			this.right = right;
			this.prev = prev;
		}

		public int max() {
			return left > right ? left : right;
		}

		public int min() {
			return left > right ? right : left;
		}
	}

	private void solveE() {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();

		PriorityQueue<Pair> queue = new PriorityQueue(N, new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				Pair p1 = (Pair)o1;
				Pair p2 = (Pair)o2;
				if (p1.min() > p2.min()) {
					return -1;
				}
				if (p1.min() < p2.min()) {
					return 1;
				}
				if (p1.max() > p2.max()) {
					return -1;
				}
				return 1;
			}
		});
		int prev = sc.nextInt();
		Pair prev_p = null;
		for (int i = 1; i < N; i++) {
			int tmp = sc.nextInt();
			Pair tmp_p = new Pair(prev, tmp, prev_p);
			queue.add(tmp_p);
			if (prev_p != null) {
				prev_p.next = tmp_p;
			}
			prev = tmp;
			prev_p = tmp_p;
		}
		ArrayDeque<Integer> answer = new ArrayDeque<>();
		while (!queue.isEmpty()) {
			Pair p = queue.poll();
			if (p.prev != null && p.next != null) {
				Pair new_p = new Pair(p.prev.left, p.next.right, p.prev.prev);
				new_p.next = p.next.next;
				queue.add(new_p);
			}
			if (p.prev != null) {
				queue.remove(p.prev);
			}
			if (p.next != null) {
				queue.remove(p.next);
			}
			answer.addFirst(p.right);
			answer.addFirst(p.left);
		}
		while (answer.size() > 1) {
			System.out.print(answer.poll() + " ");
		}
		System.out.println(answer.poll());
	}
}