#include <iostream>
#include <fstream>

using namespace std;

typedef struct
{
    long V;
    long i;
}
Heap;

Heap H[200005], Nod;
long N, P, OTip, Ordine[200005];

void Sift (Heap H[], long K)
{
    Heap Aux;
    if ((H[2*K].V<H[K].V)&&(H[2*K].V<=H[2*K+1].V)&&(2*K<N))
    {
        Ordine[H[K].i]=2*K;
        Ordine[H[2*K].i]=K;

        Aux=H[K];
        H[K]=H[2*K];
        H[2*K]=Aux;
        Sift (H, 2*K);
    }
    if ((H[2*K+1].V<H[K].V)&&(H[2*K+1].V<=H[2*K].V)&&(2*K+1<N))
    {
        Ordine[H[K].i]=2*K+1;
        Ordine[H[2*K+1].i]=K;

        Aux=H[K];
        H[K]=H[2*K+1];
        H[2*K+1]=Aux;
        Sift (H, 2*K+1);
    }
}

void Percolate (Heap H[], long K)
{
    Heap Aux;
    if (H[K].V<H[K/2].V)
    {
        Ordine[H[K].i]=K/2;
        Ordine[H[K/2].i]=K;

        Aux=H[K];
        H[K]=H[K/2];
        H[K/2]=Aux;
        Percolate (H, K/2);
    }
}

void Eliminate (Heap H[], long K)
{
    Ordine[H[N-1].i]=K;
    Ordine[H[K].i]=200010;

    H[K]=H[N-1];
    Sift (H, K);
    N--;
}

void Insert (Heap H[], Heap X)
{
    Ordine [X.i]=N;

    H[N]=X;
    Percolate (H, N);
    N++;
}

void BuildHeap (Heap H[])
{
    long i;
    for (i=(N-1)/2; i>=0; i--)
    {
        Sift (H, i);
    }
}

void HeapSort (Heap H[], long V[])
{
    long n=0;
    BuildHeap (H);
    while (N>0)
    {
        V[n++]=H[0].V;
        Eliminate (H, 0);
    }
    N=n;
}

int main()
{
    ifstream fin ("heapuri.in");
    ofstream fout ("heapuri.out");
    long i, k=0;
    fin >> P;
    for (i=0; i<P; i++)
    {
        fin >> OTip;
        if (OTip==1)
        {
            fin >> Nod.V;
            Nod.i=k;
            k++;
            Insert (H, Nod);
        }
        if (OTip==2)
        {
            fin >> Nod.i;
            Nod.i--;
            Eliminate (H, Ordine[Nod.i]);
        }
        if (OTip==3)
        {
            fout << H[0].V << "\n";
        }
    }
    fin.close ();
    fout.close ();
    return 0;
}