#include <algorithm>
#include <stdio.h>
int contor=1;

struct elem
{
    int nr;
    int ordine=0;
};
elem v[200001];
int pos[200001];
void heap(elem v[],int p)
{
    elem aux;
    int posaux;

    while(p!=1 && v[p].nr<v[p/2].nr)
    {
        posaux=pos[v[p].ordine];
        pos[v[p].ordine]=pos[v[p/2].ordine];
        pos[v[p/2].ordine]=posaux;
        aux=v[p];
        v[p]=v[p/2];
        v[p/2]=aux;
        p=p/2;

    }
}

inline void eliminatorul (elem v[],int p)
{
    elem aux;
    int posaux;
    posaux=pos[v[p].ordine];
        pos[v[p].ordine]=pos[v[contor-1].ordine];
        pos[v[contor-1].ordine]=posaux;


    v[p]=v[contor-1];

    contor--;
    bool unbalanced = true;
    while(unbalanced) ///cat timp heap-ul este nebalansat (e ceva in neregula cu el)
    {
        unbalanced = false;
        if((2*p+1)<contor)
        {
            if (v[p].nr > v[2*p].nr || v[p].nr > v[2*p+1].nr)  ///heap is unbalanced
            {
                unbalanced = true;
                if(v[2*p].nr < v[(2*p)+1].nr)
                    posaux=pos[v[p].ordine];
        pos[v[p].ordine]=pos[v[p*2].ordine];
        pos[v[p*2].ordine]=posaux;



                    aux=v[p];
                    v[p]=v[2*p];
                    v[2*p]=aux;

                    p=2*p;
                }
                else
                {
                    posaux=pos[v[p].ordine];
        pos[v[p].ordine]=pos[v[(p*2)+1].ordine];
        pos[v[(p*2)+1].ordine]=posaux;

                    aux=v[p];
                    v[p]=v[2*p+1];
                    v[2*p+1]=aux;

                    p=(2*p)+1;
                }
            }

        else
        {
            if(2*p<contor)
            {
                if (v[p].nr > v[2*p].nr)
                {posaux=pos[v[p].ordine];
        pos[v[p].ordine]=pos[v[p*2].ordine];
        pos[v[p*2].ordine]=posaux;

                    unbalanced = true;
                    aux=v[p];
                    v[p]=v[2*p];
                    v[2*p]=aux;
                    p=2*p;

                }
            }

        }
}


    unbalanced = true;
    while (unbalanced) {
        unbalanced = false;
        if (p/2 >= 1) {
            if (v[p].nr < v[p/2].nr) {
                    posaux=pos[v[p].ordine];
        pos[v[p].ordine]=pos[v[p/2].ordine];
        pos[v[p/2].ordine]=posaux;

                aux=v[p];
                v[p]=v[p/2];
                v[p/2]=aux;

                p=p/2;
                unbalanced=true;
            }

        }
    }
}

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

    int i,n;

    scanf("%d",&n);
    int cod,x,num=1;
    for(i=0; i<n; i++)
    {
        scanf("%d",&cod);
        if(cod==1)
        {
            scanf("%d",&x);
            v[contor].nr=x;
            v[contor].ordine=num;
            pos[v[contor].ordine]=contor;
            heap(v,contor);
            contor++;
            num++;
             for(int j=1;j<contor;j++);


        }
        else if (cod==2)
        {
            scanf("%d",&x);


                    eliminatorul(v,pos[x]);

        }
        else if(cod==3)
        {
            printf("%d\n", v[1].nr);


        }
    }
}