#include <iostream>
#include <fstream>
#define NMAX 200005
using namespace std;

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

int minHeap[NMAX];
int index[NMAX];
int ordine[NMAX];
int heapSize = 0;
int nr_ord = 1;

int fiuStang(int pozitie){return pozitie * 2;}

int fiuDrept(int pozitie){return pozitie * 2 + 1;}

int tata(int pozitie){return pozitie/2;}

void down(int minHeap[], int k)
{  int fiu;
    do
    {   fiu = 0;
        if(fiuStang(k) <= heapSize)
         {
              fiu = fiuStang(k);
                  if(fiuDrept(k) <= heapSize && minHeap[fiuDrept(k)] < minHeap[fiuStang(k)])
                      fiu = fiuDrept(k);
         }
         if(minHeap[fiu] >= minHeap[k])
            fiu = 0;

         if(fiu)
         {
              swap(index[minHeap[k]], index[minHeap[fiu]]);
              swap(minHeap[fiu], minHeap[k]);
              k = fiu;
         }


    }while(fiu != 0);
}

void up(int minHeap[], int k)
{
    while((k > 1) && minHeap[k] < minHeap[tata(k)])
    {
        swap(index[minHeap[k]], index[minHeap[tata(k)]]);
        swap(minHeap[k], minHeap[tata(k)]);
        k = tata(k);
    }
}
void inserare(int x)
{
    heapSize++;
    minHeap[heapSize] = x;
    index[x] = heapSize;
    ordine[nr_ord++] = x;
    down(minHeap, heapSize);
}

void stergere(int x)
{   int i = index[ordine[x]];
    swap(index[minHeap[i]], index[minHeap[heapSize]]);
    swap(minHeap[i],minHeap[heapSize]);
    heapSize--;
    if((i > 1) && (minHeap[i] < minHeap[tata(i)]))
        up(minHeap, i);
    else
        down(minHeap, i);

}

int main()
{
    int n, op, x;
    fin >> n;
    for(int i = 0; i < n; i++)
    {
        fin >> op;

        switch(op)
        {
        case 1:
            fin >> x;
            inserare(x);
            break;
        case 2:
            fin >>x;
            stergere(x); // nr de ordine nu valoarea
            break;
        case 3:
            fout << minHeap[1] << "\n";
            break;

        }
    }
    return 0;
}