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

public class Main{
  static int n;
  static int[] p;

  static final int MAX = 200000;
  static final boolean DEBUG = false;

  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);

    n = sc.nextInt();
    p = new int[n];
    for(int i = 0; i < n; i++){
      p[i] = sc.nextInt();
    }

    int[] pos = new int[MAX + 1];
    for(int i = 0; i < n; i++){
      pos[p[i]] = i;
    }

    ArrayList< Integer > a = new ArrayList< >(n);
    TreeSet< Integer > r = new TreeSet< >();
    for(int i = 0; i < n; i++){
      a.add(p[i]);
      r.add(p[i]);
    }

    Map< Integer, Integer > map = new HashMap< >();
    for(int i = 0; i < n; i++){
      map.put(p[i], i);
    }

    int[] ans = new int[n];
    int sp = 0;
    while(!r.isEmpty()){
      int x = r.first();
      int y = r.higher(x);
      if(DEBUG){
        System.out.println("x = " + x + ", y = " + y);
      }
      while(true){
        if(pos[x] > pos[y]){
          if(r.higher(y) == null){
            x = r.higher(x);
            y = r.first();
          }
          else{
            y = r.higher(y);
          }
          if(DEBUG){
            System.out.println("x = " + x + ", y = " + y);
          }
          continue;
        }
        if((pos[y] - pos[x] == map.get(y) - map.get(x)) &&
          ((pos[y] - pos[x] + 1) % 2 == 0) &&
          (a.indexOf(x) % 2 == 0 && (n - a.indexOf(y) + 1) % 2 == 0)){
          ans[sp++] = x;
          ans[sp++] = y;
          r.remove(x);
          r.remove(y);
          a.remove(new Integer(x));
          a.remove(new Integer(y));
          for(int i = 0; i < a.size(); i++){
            map.put(a.get(i), i);
          }
          map.remove(x);
          map.remove(y);
          if(DEBUG){
            System.out.println("added");
            System.out.println("x = " + x + ", y = " + y);
          }
          break;
        }
        else{
          if(r.higher(y) == null){
            x = r.higher(x);
            y = r.first();
          }
          else{
            y = r.higher(y);
          }
          if(DEBUG){
            System.out.println("x = " + x + ", y = " + y);
          }
        }
      }
    }

    StringBuilder sb = new StringBuilder();
    for(int i = 0; i < n; i++){
      sb.append(ans[i] + " ");
    }

    System.out.println(sb);
  }
}