代码：

#define debug
#include<bits/stdc++.h>

#define endl '\n';

using namespace std;

const int N = 5e5 + 5;

int n;

struct Node{
  int l, r;
  int val, size;
  int cnt;
}spl[N];

int cnt, root;

void newnode(int &node, int &val){
  spl[node = ++cnt].val = val;
  spl[cnt].size++;
  spl[cnt].cnt++;
}

void update(int node){
  spl[node].size = spl[spl[node].l].size + spl[spl[node].r].size + spl[node].cnt;
}

void zig(int &node){
  int l = spl[node].l;
  spl[node].l = spl[l].r;
  spl[l].r = node;
  node = l;
  update(spl[node].r);
  update(node);
}

void zag(int &node){
  int r = spl[node].r;
  spl[node].r = spl[r].l;
  spl[r].l = node;
  node = r;
  update(spl[node].l);
  update(node);
}

void splaying(int x, int &y){ //伸展
  if(x == y){
    return ;
  }
  int &l = spl[y].l, &r = spl[y].r;
  if(x == l){
    zig(y);
  }
  else if(x == r){
    zag(y);
  }
  else{
    if(spl[x].val < spl[y].val){
      if(spl[x].val < spl[l].val){
        splaying(x, spl[l].l);
        zig(y);
        zig(y);
      }
      else{
        splaying(x, spl[l].r);
        zag(l);
        zig(y);
      }
    }
    else{
      if(spl[x].val > spl[r].val){
        splaying(x, spl[r].r);
        zag(y);
        zag(y);
      }
      else{
        splaying(x, spl[r].l);
        zig(r);
        zag(y);
      }
    }
  }
}

void delnode(int node){
  splaying(node, root);
  if(spl[node].cnt > 1){
    spl[node].size--;
    spl[node].cnt--;
  }
  else if(spl[root].r){
    int p = spl[root].r;
    while(spl[p].l){
      p = spl[p].l;
    }
    splaying(p, spl[root].r);
    spl[spl[root].r].l = spl[root].l;
    root = spl[root].r;
    update(root);
  }
  else{
    root = spl[root].l;
  }
}

void insert(int &node, int &val){
  if(!node){
    newnode(node, val);
    splaying(node, root);
  }
  else if(val < spl[node].val){
    insert(spl[node].l, val);
  }
  else if(val > spl[node].val){
    insert(spl[node].r, val);
  }
  else{
    spl[node].size++;
    spl[node].cnt++;
    splaying(node, root);
  }
}

void del(int node, int val){
  if(spl[node].val == val){
    delnode(node);
  }
  else if(val < spl[node].val){
    del(spl[node].l, val);
  }
  else{
    del(spl[node].r, val);
  }
}

int _rank(int val){
  int node = root, rk = 1;
  while(node){
    if(spl[node].val == val){
      rk += spl[spl[node].l].size;
      splaying(node, root);
      break;
    }
    if(val <= spl[node].val){
      node = spl[node].l;
    }
    else{
      rk += spl[spl[node].l].size + spl[node].cnt;
      node = spl[node].r;
    }
  }
  return rk;
}

int query(int rk){
  int node = root;
  while(node){
    int lsize = spl[spl[node].l].size;
    if(lsize + 1 <= rk && rk <= lsize + spl[node].cnt){
      splaying(node, root);
      break;
    }
    else if(lsize >= rk){
      node = spl[node].l;
    }
    else{
      rk -= lsize + spl[node].cnt;
      node -= spl[node].r;
    }
  }
  return spl[node].val;
}

void Solve(){
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n;
  while(n--){
    int op;
    cin >> op;
    if(op == 1){
      int x;
      cin >> x;
      insert(root, x);
    }
    else if(op == 2){
      int x;
      cin >> x;
      del(root, x);
    }
    else if(op == 3){
      int x;
      cin >> x;
      cout << _rank(x) << endl;
    }
    else if(op == 4){
      int x;
      cin >> x;
      cout << query(x) << endl;
    }
    else if(op == 5){
      int x;
      cin >> x;
      cout << query(_rank(x) - 1) << endl;
    }
    else{
      int x;
      cin >> x;
      cout << query(_rank(x + 1)) << endl;
    }
  }
}

signed main(){
#ifdef debug
  freopen("Code.in", "r", stdin);
  freopen("Code.out", "w", stdout);
#endif
  Solve();
  return 0;
}