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

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

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

    }
}

inline void eliminatorul (elem v[],int p)
{
    elem aux;
    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)
                {

                    aux=v[p];
                    v[p]=v[2*p];
                    v[2*p]=aux;
                    swap(pos[v[p].ordine],pos[v[p*2].ordine]);

                    p=2*p;
                }
                else
                {
                    swap(pos[v[p].ordine],pos[v[(p*2)+1].ordine]);
                    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)
                {
                    swap(pos[v[p].ordine],pos[v[p*2].ordine]);
                    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) {
                    swap(pos[v[p].ordine],pos[v[p/2].ordine]);
                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++;

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

                    eliminatorul(v,pos[x]);

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