#include <fstream>
#define NMAX 200002
using namespace std;
ifstream fin("heapuri.in");
ofstream fout("heapuri.out");
int n,a,cod,nr,lg,p,x,v[NMAX],lg1;
int H[NMAX];
void creare(int H[], int &n);
void creare_comb(int H[],int &n);
void inserare(int H[], int &n, int x, int lg1);
void combinare(int H[], int n, int i);
void afisare(int H[], int n);
int extrage_min(int H[], int &n);
void sterge( int H[], int &n, int x);
int main()
{
    fin>>a;
    for(int i=1;i<=a;i++)
    {
        fin>>cod;
        if(cod==1)
        {
            fin>>x;
            lg1++;
            inserare(H,lg,x,lg1);
           // fout<<' ';
           // afisare(H,lg);
           // fout<<'\n';
        }
        else
        if(cod==3)
        {
            fout<<H[1];
            fout<<'\n';
        }
        else
        if(cod==2)
        {
            fin>>p;
            for(int j=1;j<=lg;j++)
                if(v[j]==p)
                    sterge(H,lg,j);
            //afisare(H,lg);

        }


    }
    //creare_comb(H,n);

    return 0;
}

void creare(int H[], int &n)
{
    int i,x,nr;
    fin>>nr;
    n=0;
    for(i=0;i<nr;i++)
    {
        fin>>x;
        inserare(H,n,x,lg1);
    }
}
void afisare(int H[], int n)
{
    for(int i=1;i<=n;i++)
        fout<<H[i]<<' ';
}
void inserare(int H[], int &n, int x, int lg1)
{
    int poz=n+1,tpoz=poz/2;
    while(H[tpoz]>x && tpoz>0)
    {
        v[poz]=v[tpoz];
        H[poz]=H[tpoz];
        poz=tpoz;
        tpoz=poz/2;
    }
    H[poz]=x;
    v[poz]=lg1;
    n++;
}
void combinare(int H[], int n, int i)
{
    //combin heapurile corecte cu radacinile 2i si 2i+1 cu nodul i
    int x=H[i], tata=i,fiu=2*i;
    while(fiu<=n)
    {
        //daca exista fiu drept si e mai mic
        if(fiu+1<=n && H[fiu+1]<H[fiu])
            fiu++;
        if(H[fiu]<x)
        {
            v[tata]=v[fiu];
            H[tata]=H[fiu];
            tata=fiu;
            fiu=fiu*2;
        }
        else
        break;
    }

    H[tata]=x;
}
void creare_comb(int H[],int &n)
{
    int i;
    for(i=n/2;i>0;i--)
        combinare(H,n,i);
}
int extrage_min(int H[], int &n)
{
    int minim=H[1];
    H[1]=H[n--];
    combinare(H,n,1);
    return minim;
}
void sterge( int H[], int &n, int p)
{
    v[p]=v[n];
    H[p]=H[n--];
    //n--;
    combinare(H,n,1);
}