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

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

int minHeap[NMAX], val[NMAX], pozitie[NMAX];
int nr_ord = 1;
int heapSize = 0;

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

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

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




void up(int index)
{
    if (index > 0)
    {
        int tata = index/2;
        if( val[minHeap[tata]] > val[minHeap[index]])
        {
            swap(minHeap[tata], minHeap[index]);
            swap(pozitie[minHeap[tata]], pozitie[minHeap[index]]);
            up(tata);
        }
    }
}
void down(int k)
{
    int fiu;
    do
    {
        fiu = 0;

        if(fiuStang(k) <= heapSize)
        {
            fiu = fiuStang(k);

            if(fiuDrept(k) <= heapSize && val[minHeap[fiuDrept(k)]] < val[minHeap[fiuStang(k)]])
                fiu = fiuDrept(k);
        }

        if(val[minHeap[fiu]] >= val[minHeap[k]])
            fiu = 0;

        if(fiu)
        {
            swap(minHeap[k],minHeap[fiu]);
            swap(pozitie[minHeap[k]], pozitie[minHeap[fiu]]);
            k = fiu;
        }
    }while(fiu != 0);

}
void inserare(int x)
{
    minHeap[++heapSize] = x;
    pozitie[x] = heapSize;
    up(heapSize);
}

void stergere(int x)
{
    int index = pozitie[x];
    swap(minHeap[index],minHeap[heapSize]);
    swap(pozitie[minHeap[index]],pozitie[minHeap[heapSize]]);
    heapSize--;
    up(index);
    down(index);
}

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

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

    }
    return 0;
}