Problem: Your task is to simulate the sequence defined in the remaining part of the problem description.

This sequence is empty at first.  i -th element of this sequence is expressed as  ai . The first element of this sequence is  a1 if the sequence is not empty. The operation is given by integer from 0 to 9. The operation is described below.

0: This query is given with some integer x. If this query is given, the integer x is inserted into the sequence. If the sequence is empty, a1 = x. If the sequence has n elements, an+1 = x. Same integer will not appear more than once as x.

1: If this query is given, one element in the sequence is deleted. The value in the middle of the sequence is deleted. If the sequence has n elements and  n  is even,  an/2 will be deleted. If  n  is odd,  a⌈n/2⌉ will be deleted. This query is not given when the sequence is empty. Assume that the sequence has  a1 =1, a2 =2, a3 =3, a4 =4 and  a5 =5. In this case,  a3 will be deleted. After deletion, the sequence will be  a1 =1,  a2 =2, a3 =4, a4 =5. Assume that the sequence has  a1 =1, a2 =2, a3 =3 and  a4 =4, In this case,  a2 will be deleted. After deletion, the sequence will be  a1 =1, a2 =3,  a3 =4.

2: The first half of the sequence is defined by the index from 1 to ⌈n/2⌉ . If this query is given, you should compute the minimum element of the first half of the sequence. This query is not given when the sequence is empty.

Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case, the minimum element of the first half of the sequence, {6,2,3,4} is 2.

3: The latter half of the sequence is elements that do not belong to the first half of the sequence. If this query is given, you should compute the minimum element of the latter half of the sequence. This query is not given when the sequence is empty.

Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case the answer for this query is 1 from {5,1,8}.

4: This query is given with an integer i. Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 2. You should compute the  i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that  i -th minimum element exists when this query is given.

Let me show an example.


Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,3,5,1,8}   The minimum element in the first half of the sequence is 2.
{6,2,5,1,8}     The minimum element in the first half of the sequence is 2.
{6,2,1,8}       The minimum element in the first half of the sequence is 2.
{6,1,8}         The minimum element in the first half of the sequence is 1.
{6,8}           The minimum element in the first half of the sequence is 6.
{8}             The minimum element in the first half of the sequence is 8.
{}              The first half of the sequence is empty.


For the initial state, {6,2,3,4} is the first half of the sequence. 2 and 6 become the minimum element of the first half of the sequence. In this example, the 1-st minimum element is 2 and the 2-nd is 6.

5: This query is given with an integer  i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 3. You should compute the  i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that  i -th minimum element exists when this query is given.

Let me show an example.


Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,3,5,1,8}   The minimum elemets in the latter half of the sequence is 1.
{6,2,5,1,8}     The minimum elemets in the latter half of the sequence is 1.
{6,2,1,8}       The minimum elemets in the latter half of the sequence is 1.
{6,1,8}         The minimum elemets in the latter half of the sequence is 8.
{6,8}           The minimum elemets in the latter half of the sequence is 8.
{8}             The latter half of the sequence is empty.
{}              The latter half of the sequence is empty.


For the initial state, {5,1,8} is the latter half of the sequence. 1 and 8 becomes the minimum element of the latter half ot the sequence. In this example, the 1-st minimum element is 1 and the 2-nd is 8.

6: If this query is given, you should compute the maximum element of the first half of the sequence. This query is not given when the sequence is empty.

Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the first half of the sequence,{1,3,2,5}, is 5.

7: If this query is given, you should compute the maximum element of the latter half of the sequence. This query is not given when the sequence is empty.

Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the latter half of the sequence,{9,6,7}, is 9.

8: This query is given with an integer  i . Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 6. You should compute the  i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that  i -th maximum elements exists when this query is given.

Let me show an example.


Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the first half of the sequence is 5.
{1,3,2,9,6,7}   The maximum element in the first half of the sequence is 3.
{1,3,9,6,7}     The maximum element in the first half of the sequence is 9.
{1,3,6,7}       The maximum element in the first half of the sequence is 3.
{1,6,7}         The maximum element in the first half of the sequence is 6.
{1,7}           The maximum element in the first half of the sequence is 1.
{7}             The maximum element in the first half of the sequence is 7.
{}              The first half of the sequence is empty.


For the initial state, {1,3,2,5} is the first half of the sequence. 1,3 and 5 becomes the maximum element of the first half of the sequence. In this example, the 1-st maximum element is 5, the 2-nd is 3 and the 3-rd is 1.

9: This query is given with an integer  i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 7. You should compute the  i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that  i -th maximum elements exists when this query is given.

Let me show an example.


Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,2,9,6,7}   The maximum element in the latter half of the sequence is 9.
{1,3,9,6,7}     The maximum element in the latter half of the sequence is 7.
{1,3,6,7}       The maximum element in the latter half of the sequence is 7.
{1,6,7}         The maximum element in the latter half of the sequence is 7.
{1,7}           The maximum element in the latter half of the sequence is 7.
{7}             The latter half of the sequence is empty.
{}              The latter half of the sequence is empty.


For the initial state, {9,6,7} is the latter half of the sequence. 7 and 9 becomes the maximum element of the latter half of the sequence. In this example, the 1-st maximum element is 9 and the 2-nd is 7.



Input

Input consists of multiple test cases. The first line is the number of queries. Following q lines are queries.


q
query0
...
queryi
...
qurey_q-1


The sum of the number of queries in the input data is less than 200001. If queryi = 0, 4, 5, 8, and 9 are consists of pair of integers. Other queries are given with a single integer. You can assume that the length of the sequence doesn't exceed 20000.

Output

If the query is 0, you don't output any numbers. If the query is 1, you should output the deleted number. For other queries, you should output the computed value. For each case, you should output "end" (without quates) after you process all queries.

Example

Input

5
0 1
0 2
0 3
0 4
1
6
0 1
0 2
0 3
0 4
0 5
1
31
0 6
0 2
0 3
0 4
0 5
0 1
0 8
4 1
4 2
5 1
5 2
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
1
32
0 1
0 3
0 2
0 5
0 9
0 6
0 7
8 1
8 2
8 3
9 1
9 2
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
1
0


Output

2
end
3
end
2
6
1
8
2
1
4
2
1
3
2
1
5
2
1
2
1
8
1
6
8
6
8
8
end
5
3
1
9
7
5
9
5
3
9
2
9
7
9
3
7
3
6
7
6
1
7
1
7
7
end

Solution (in CPP):

Solution:
/*
 * AOJ 1070: FIMO sequence
 * ?¢???????????§???????????????????10?§??????????????°??????\???????????°????????°???????????°??????????±?????????????????????§????°??????????????????????????????°?????????????¬????????????????????????????????????§????°??????°????±???¶????¬¬i??§??????
 * ?±???????????????????
 * ???????????´???6???????????????????????????????????°??????????°???????????°?????????????????????????????????????????????°??????????°±?????´?°??????\?????´?°?????????????????????????
 */

#include <cstdio>

const int MAXN = 200010;

int la[MAXN], ls[MAXN], lb[MAXN], ra[MAXN], rs[MAXN], rb[MAXN];
int la1, la2, ls1, ls2, lb1, lb2, ra1, ra2, rs1, rs2, rb1, rb2, m;

void outall() {
  printf("----outall----\n");
  for (int i = la1; i < la2; ++i) {
    printf("%d ", la[i]);
  }
  printf("\n");
  for (int i = ls1; i < ls2; ++i) {
    printf("%d ", ls[i]);
  }
  printf("\n");
  for (int i = lb1; i < lb2; ++i) {
    printf("%d ", lb[i]);
  }
  printf("\n");
  for (int i = ra1; i < ra2; ++i) {
    printf("%d ", ra[i]);
  }
  printf("\n");
  for (int i = rs1; i < rs2; ++i) {
    printf("%d ", rs[i]);
  }
  printf("\n");
  for (int i = rb1; i < rb2; ++i) {
    printf("%d ", rb[i]);
  }
  printf("\n");
  printf("\n");
}

void left_push_back(int x) {
  la[la2++] = x;
  if (ls2 == ls1 || ls[ls2 - 1] > x) {
    ls[ls2++] = x;
  }
  if (lb2 == lb1 || lb[lb2 - 1] < x) {
    lb[lb2++] = x;
  }
}

void right_push_back(int x) {
  ra[ra2++] = x;
  while (rs2 > rs1 && rs[rs2 - 1] > x) {
    --rs2;
  }
  rs[rs2++] = x;
  while (rb2 > rb1 && rb[rb2 - 1] < x) {
    --rb2;
  }
  rb[rb2++] = x;
}

int right_pop_front() {
  if (ra[ra1] == rs[rs1]) ++rs1;
  if (ra[ra1] == rb[rb1]) ++rb1;
  ++ra1;
  return ra[ra1 - 1];
}

int left_pop_back() {
  if (la[la2 - 1] == ls[ls2 - 1]) --ls2;
  if (la[la2 - 1] == lb[lb2 - 1]) --lb2;
  --la2;
  return la[la2];
}

void f0_add() {
  int x;
  scanf("%d", &x);
  if (m == 0) {
    left_push_back(x);
  } else {
    right_push_back(x);
    if (!(m & 1)) {
      int y = right_pop_front();
      left_push_back(y);
    }
  }
  ++m;
//  outall();
}

void f1_del() {
  int x = left_pop_back();
  printf("%d\n", x);
  if (!(m & 1)) {
    int y = right_pop_front();
    left_push_back(y);
  }
  --m;
}

void f2_ls() {
  int x = ls[ls2 - 1];
  printf("%d\n", x);
}

void f3_rs() {
  int x = rs[rs1];
  printf("%d\n", x);
}

void f4_ls_() {
  int i, x;
  scanf("%d", &i);
  x = ls[ls2 - i];
  printf("%d\n", x);
}

void f5_rs_() {
  int i, x;
  scanf("%d", &i);
  x = rs[rs1 + i - 1];
  printf("%d\n", x);
}

void f6_lb() {
  int x = lb[lb2 - 1];
  printf("%d\n", x);
}

void f7_rb() {
  int x = rb[rb1];
  printf("%d\n", x);
}

void f8_lb_() {
  int i, x;
  scanf("%d", &i);
  x = lb[lb2 - i];
  printf("%d\n", x);
}

void f9_rb_() {
  int i, x;
  scanf("%d", &i);
  x = rb[rb1 + i - 1];
  printf("%d\n", x);
}

int main() {
//  freopen("/Users/yogy/acm-challenge-workbook/db.in", "r", stdin);
  int n;
  while (scanf("%d", &n) != EOF && n) {
    m = la1 = la2 = ls1 = ls2 = lb1 = lb2 = ra1 = ra2 = rs1 = rs2 = rb1 = rb2 = 0;
    while (n--) {
      int t;
      scanf("%d", &t);
//      printf("type = %d\n", t);
      switch (t) {
        case 0:
          f0_add();
          break;
        case 1:
          f1_del();
          break;
        case 2:
          f2_ls();
          break;
        case 3:
          f3_rs();
          break;
        case 4:
          f4_ls_();
          break;
        case 5:
          f5_rs_();
          break;
        case 6:
          f6_lb();
          break;
        case 7:
          f7_rb();
          break;
        case 8:
          f8_lb_();
          break;
        case 9:
          f9_rb_();
          break;
      }
    }
    printf("end\n");
  }
  return 0;
}