#include <fstream>

using namespace std;

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

int n,x,operatie,p=1;
int heap[200005],ordine[200005],pozitie[1000000001];

//Prin vectorul ordine tin minte ce elemnt a fost inserate al i-lea
//De fiecare data cand fac sift,fa_heap sau inserare (la stergere fac sift/fa_heap) reschimb pozitiile.

//Procedura asta e de pe infoarena si il face heap incepand cu pozitia k (in jos) - sau asa cred :)
void sift(int heap[],int &inaltime,int k)
{
    int fiu,aux;
    do{
        fiu=0;
        if(2*k <= inaltime)
        {
            fiu=2*k;
            if(2*k+1 <= inaltime && heap[2*k+1]<heap[2*k]) fiu=2*k+1;
            if(heap[fiu] >= heap[k]) fiu=0;
        }
        if(fiu){
            pozitie[heap[fiu]]=k;
            pozitie[heap[k]]=fiu;
            aux=heap[k];
            heap[k]=heap[fiu];
            heap[fiu]=aux;
        }
    }while(fiu);
    return;
}

//Si asta e tot de pe infoarena si face vectorul meu heap doar ca opus lui sift(adica in sus) - sau asa cred :)
void fa_heap(int heap[],int &inaltime,int k)
{
    int cheie=heap[k];

    while((k>1) && (cheie<heap[k/2]))
    {
        heap[k]=heap[k/2];
        pozitie[heap[k/2]]=k;
        k=k/2;
    }
    pozitie[cheie]=k;
    heap[k]=cheie;
    return;
}

//Inserare de element in heap
void inserare_heap(int heap[],int &inaltime,int x)
{
    inaltime++;
    heap[inaltime]=x;
    ordine[p]=x;
    p++;
    pozitie[x]=inaltime;
    fa_heap(heap,inaltime,inaltime);
    return;
}

//stergere element din heap
void stergere_heap(int heap[],int &inaltime,int poz)
{
    heap[poz]=heap[inaltime];
    inaltime--;
    if(poz>1 && heap[poz]<heap[poz/2]) fa_heap(heap,inaltime,poz);
        else sift(heap,inaltime,poz);
    return;
}


int main()
{
    int i,inaltime;
    in>>n;
    inaltime=0;
    for(i=1;i<=n;i++)
    {
        in>>operatie;
        if(operatie==1)
        {
            in>>x;
            inserare_heap(heap,inaltime,x);
        }
        if(operatie==2)
        {
            in>>x;
            if(inaltime>0) stergere_heap(heap,inaltime,pozitie[ordine[x]]);
        }
        if(operatie==3)
        {
            out<<heap[1]<<"\n";
        }
    }
    in.close();
    out.close();
    return 0;
}