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.ArrayList;
import java.util.Scanner;

public class Main {

	private void solve() {
		Scanner io = new Scanner(System.in);
		int N = io.nextInt();
		ArrayList<ArrayList<Integer>> input = new ArrayList<>();
		ArrayList<Integer> first = new ArrayList<>();
		for(int i=0;i<N;i++){
			first.add(io.nextInt());
		}
		input.add(first);
		ArrayList<Integer> ans = new ArrayList<>();
		
		do{
			input = getTwo(input);
			ans.addAll(input.get(0));
			input.remove(0);
		}while(!input.isEmpty());
		
		for(int i=0;i<ans.size();i++){
			System.out.print(ans.get(i) + ((i==ans.size()-1)?"\n":" "));
		}
		
	}
	
	private ArrayList<ArrayList<Integer>> 
			getTwo(ArrayList<ArrayList<Integer>> list){
		int min = Integer.MAX_VALUE;
		int min_i = 0;
		int min_j = 0;
		for(int i=0;i<list.size();i++){
			for(int j=0;j<list.get(i).size();j++){
				if((j&1)==0){
					int num = list.get(i).get(j);
					if(num<min){
						min = num;
						min_i = i;
						min_j = j;
					}
				}
			}
		}
		int next = Integer.MAX_VALUE;
		int next_j = 0;
		for(int j=min_j+1;j<list.get(min_i).size();j++){
			if(((j-min_j-1)&1)==0){
				int num = list.get(min_i).get(j);
				if(num<next){
					next = num;
					next_j = j;
				}
			}
		}
		ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
		ArrayList<Integer> ansNums = new ArrayList<>();
		ansNums.add(min);
		ansNums.add(next);
		ans.add(ansNums);
		for(int i=0;i<list.size();i++){
			if(i==min_i){
				ArrayList<Integer> splited = new ArrayList<>();
				for(int j=0;j<list.get(min_i).size();j++){
					if((j==min_j || j==next_j)){
						if(!splited.isEmpty()){
							ans.add(splited);
							splited = new ArrayList<>();
						}
					}else{
						splited.add(list.get(min_i).get(j));
					}
				}
				if(!splited.isEmpty()) ans.add(splited);
			}else{
				ans.add(list.get(i));
			}
		}
		return ans;
	}

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