#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

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

#define nmax 200005

int n,task,q=0,x,c=0,nr=0,Poz[nmax],son1,son2,Father,pozi,aux;

struct Heapuri
{
    int nr,poz;
}Heap[nmax];

void UpHeap(int x)
{
    int Father=x/2;
    if(Father>0 && Heap[x].nr<Heap[Father].nr)
    {
        swap(Heap[x],Heap[Father]);
        Poz[Heap[x].poz]=x;
        Poz[Heap[Father].poz]=Father;
        UpHeap(Father);
    }
}

void DownHeap(int x)
{
    int son1=x*2,son2=x*2+1,aux=0;
    if(son2<=q)
    {
        if(Heap[son1].nr<=Heap[son2].nr)
            aux=son1;
        else
            aux=son2;
    }
    else
    {
        if(son1<=q)
            aux=son1;
    }
    if(aux>0 && Heap[aux].nr<Heap[x].nr)
    {
        swap(Heap[aux],Heap[x]);
        Poz[Heap[x].poz]=x;
        Poz[Heap[aux].poz]=aux;
        DownHeap(aux);
    }
}

int main()
{
    fin>>n;
    for(int i=1;i<=n;i++)
    {
        fin>>task;
        switch(task)
        {
        case 1:
            {
                fin>>x;
                q++;
                Heap[q].nr=x;
                c++;
                Heap[q].poz=c;
                Poz[Heap[q].poz]=q;
                UpHeap(q);
                break;
            }
        case 2:
            {
                fin>>x;
                pozi=Poz[x];
                swap(Heap[pozi],Heap[q]);
                q--;
                son1=pozi*2;
                son2=pozi*2+1;
                Father=pozi/2;
                if(son1<son2)
                    aux=son1;
                else
                    aux=son2;
                if(aux<=q)
                {
                    if(!Father)
                        DownHeap(pozi);
                    else
                    {
                        if(Heap[pozi].nr>Heap[Father].nr)
                            DownHeap(pozi);
                        else
                            UpHeap(pozi);
                    }
                }
                else
                {
                    if(!Father)
                        DownHeap(pozi);
                    else
                        UpHeap(pozi);

                }
                break;
            }
        case 3:
            {
                fout<<Heap[1].nr<<'\n';
                break;
            }
        }
    }
}