#include <iostream>
#include <vector>
#include <fstream>

std::ofstream fout("heapuri.out");
std::ifstream fin("heapuri.in");

using namespace std;

// RMQ

// int RMQ(int i, int j, int **M, int* v)
// {
//   if (i > j)
//     return 0x3f3f3f3f;

//   if (i == j)
//     return M[i][0];

//   if (i + 1 == j)
//     return M[i][1];

//   int p, log2;
//   for (log2 = 1, p = 2; p + i <= j; p *= 2, log2++)
//     ;
//   log2--;
//   p /= 2;

//   int min = RMQ(i + p, j, M, v);
//   return v[min] < v[M[i][log2]] ? (min) : (M[i][log2]);
// }

// void Preprocesare(int **M, int *v, int n)
// {
//   for (int i = 0; i < n; i++)
//     M[i][0] = i;
  
//   for (int j = 1; 1 << j <= n; j++)
//   {
//     for (int i = 0; i + (1 << j) - 1 < n; i++)
//     {
//       if (v[M[i][j - 1]] <= v[M[i + (1 << j - 1)][j - 1]])
//         M[i][j] = M[i][j - 1];
//       else
//         M[i][j] = M[i + (1 << j - 1)][j - 1];
//     }
//   }
// }

// int main()
// {
//   int n, m, *v;
//   fin >> n >> m;
//   v = new int[n];
//   int log2, p;

//   for (log2 = 1, p = 2; p <= n; log2++, p *= 2)
//     ;

//   int **M = new int *[n];
//   for (int i = 0; i <= n; i++)
//     M[i] = new int[log2];

//   for (int i = 0; i < n; i++)
//   {
//     fin >> v[i];
//   }
  
//   for (int i = 0; i < n; i++)
//   {
//     for (int j = 0; j < log2; j++)
//       M[i][j] = 0x3f3f3f3f;
//   }
//   Preprocesare(M, v, n);

//   for (int i = 0; i < m; i++)
//   {
//     int p, q;
//     fin >> p >> q;
//     p--, q--;
//     // raspuns
//     fout << v[RMQ(p, q, M, v)] << endl;
//   }

//   for (int i = 0; i < n; i++)
//   {
//     delete[] M[i];
//   }
//   delete[] M;
//   delete[] v;
//   return 0;
// }

// Heapuri

int father(int k)
{
  return (k - 1) / 2;
}

int left_son(int k) {
  return 2 * k + 1;
}

int right_son (int k)
{
  return 2 * k + 2;
}

void Percolate(vector<int> &h, vector<int> &o)
{
  int k = h.size() - 1;

  while (k > 0 && h[k] < h[father(k)])
  {
    swap(h[k], h[father(k)]);
    swap(o[k], o[father(k)]);
    k = father(k);
  }
}

void Sift(vector<int> &h, vector<int> &o, int k)
{
  int son;
  int size = h.size();
  do {
    son = 0;
    if (left_son(k) < size){
        son = left_son(k);
      if(right_son(k) < size && h[son] > h[right_son(k)])
        son = right_son(k);
      if (h[son] >= h[k])
        son = 0;
    }

    if(son){
      swap(h[son], h[k]);
      swap(o[son], o[k]);
      k = son;
    }
  } while(son);
}

void Insereaza(vector<int> &h, vector<int> &o, int val, int ord)
{
  h.push_back(val);
  o.push_back(ord);
  Percolate(h, o);
}

void AfiseazaVal(vector<int> h)
{
  fout << h[0] << endl;
}

void Elimina(vector<int>& h, vector<int> o, int poz)
{
  swap(h[poz], h[h.size() - 1]);
  swap(o[poz], o[o.size() - 1]);
  h.pop_back();
  o.pop_back();
  if (poz > 0 && h[poz] < h[father(poz)]){
    swap(h[poz], h[h.size() - 1]);
    swap(o[poz], o[o.size() - 1]);
    Percolate(h, o);
  }
  else
    Sift(h, o, poz);
}

int main()
{
  vector<int> heap;
  vector<int> ordine;
  
  int n;
  fin >> n;
  int cnt = 1;
  for (int i = 1; i <= n; i++)
  {

    int comanda;
    fin >> comanda;
    switch (comanda)
    {
    case 1:
    {
      int valoare;
      fin >> valoare;
      Insereaza(heap, ordine, valoare, cnt++);
      break;
    }
    case 2:
    {
      int valoare;
      fin >> valoare;
      int j;
      for (j = 0; j < ordine.size(); j ++)
        if (ordine[j] == valoare)
        {
          break;
        }
      Elimina(heap, ordine, j);
      break;
    }
    case 3:
    {
      AfiseazaVal(heap);
      break;
    }
    }
  }
  return 0;
}