#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <cassert>

#define SUCHLOOP while(1)

using namespace std;

template<class T>
class node{
public:
  int dad, lt, rt;
  T key;

  node(){};

  node(T key1, int dad1){
    key = key1;
    dad = dad1;
    lt = -1;
    rt = -1;
  }

  node(T key1, int dad1, int lt1, int rt1){
    dad = dad1;
    key = key1;
    lt = lt1;
    rt = rt1;
  }
};

template<class T>
class ranset{
public:

  void insert(T x){
    if(_t.empty()){
      _t.push_back(node<T>(x, -1));
      return;
    }

    int cnod = 0;
    SUCHLOOP{
      if(_t[cnod].key > x){
        if(_t[cnod].lt == -1){
          _t[cnod].lt = _t.size();
          _t.push_back(node<T>(x, cnod));
          break;
        }
        else
          cnod = _t[cnod].lt;
      }
      else{
        if(_t[cnod].rt == -1){
          _t[cnod].rt = _t.size();
          _t.push_back(node<T>(x, cnod));
          break;
        }
        else
          cnod = _t[cnod].rt;
      }
    }
  }

  T min(){
    int cnod = 0;
    while(_t[cnod].lt != -1)
      cnod = _t[cnod].lt;
    return _t[cnod].key;
  }

  void erase(T x){
    int pnow = find(x, 0);
    erase1(pnow);
  }
private:
  vector<node<T> > _t;
  int _q;

  int find(T x, int pos){
    if(pos == -1)
      return pos;
    if(_t[pos].key == x)
      return pos;
    if(_t[pos].key > x)
      return find(x, _t[pos].lt);
    return find(x, _t[pos].rt);
  }

  void erase1(int pos){
    if(_t[pos].lt == -1 && _t[pos].rt == -1){
      delson(_t[pos].dad, _t[pos].key);
      return;
    }

    if(_t[pos].lt == -1){
      adson(_t[pos].dad, _t[pos].rt);
      _t[pos] = _t[_t[pos].rt];
      return;
    }

    if(_t[pos].rt == -1){
      adson(_t[pos].dad, _t[pos].lt);
      _t[pos] = _t[_t[pos].rt];
      return;
    }

    _q = min(_t[pos].rt);
    swap(_t[pos].key, _t[_q].key);
    erase1(_q);
  }

  void adson(int pos1, int pos2){
    if(pos1 == -1){
      _t[pos2].dad = -1;
      return;
    }
    _t[pos2].dad = pos1;
    if(_t[pos1].key <= _t[pos2].key)
      _t[pos1].rt = pos2;
    else
      _t[pos1].lt = pos1;
  }

  void delson(int pos, T v){
    if(pos == -1){
      _t.clear();
      return;
    }
    if(_t[pos].key > v)
      _t[pos].lt = -1;
    else
      _t[pos].rt = -1;
  }

  int min(int pos){
    while(_t[pos].lt != -1)
      pos = _t[pos].lt;
    return pos;
  }
};

ranset<int> pheap;

int main(){
  freopen("heapuri.in", "r", stdin);
  freopen("heapuri.out", "w", stdout);

  int n;
  scanf("%d", &n);
  vector<int> op;
  for(int i = 1; i <= n; ++i){
    int tip;
    scanf("%d", &tip);
    if(tip == 1){
      int x;
      scanf("%d", &x);
      op.push_back(x);
      pheap.insert(x);
    }
    else if(tip == 2){
      int x;
      scanf("%d", &x);
      pheap.erase(op[x - 1]);
    }
    else
      printf("%d\n", pheap.min());
  }

  assert(0);

  return 0;
}