#include <fstream>

using namespace std;

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

int Heap[200010],Hes[200010],Poz[200010],i,n,op,val,N,tot;

int father( int x )
{
    return x / 2;
}

int left( int x )
{
    return x * 2;
}

int right( int x )
{
    return x * 2 + 1;
}

void sift( int pos )
{
    int son;

    do
    {
        son = 0;

        if( left( pos ) <= N )
        {
            son = left( pos );

            if( right( pos ) <= N && Hes[ Heap[ left( pos ) ] ] > Hes[ Heap[ right( pos ) ] ] )
            {
                son = right( pos );
            }

            if( Hes[ Heap[ son ] ] > Hes[ Heap[ pos ] ] )
                son = 0;

        }

        if( son )
        {
            swap( Heap[ son ] , Heap[ pos ] );
            swap( Poz[ Heap[ son ] ] , Poz[ Heap[ pos ] ] );

            pos = son;
        }

    }while( son );
}

void percolate( int pos )
{
    while( pos > 1 && Hes[ Heap[ pos ] ] < Hes[ Heap[ father( pos ) ] ] )
    {
        swap( Poz[ Heap[ pos ] ] , Poz[ Heap[ father( pos ) ] ] );
        swap( Heap[ pos ] , Heap[ father( pos ) ] );

        pos = father( pos );
    }
}

int main()
{
    fin>>n;
    for( i = 1 ; i <= n ; i++ )
    {
        fin>>op;
        if( op == 1 )
        {
            fin>>val;
            ++tot;
            ++N;
            Heap[ N ] = tot;
            Hes[ tot ] = val;
            Poz[ tot ] = N;

            percolate( N );
        }
        else if( op == 2 )
        {
            fin>>val;
            --N;

            Heap[ Poz[ val ] ] = Heap[ N + 1 ];

            if( Hes[ Heap[ Poz[ val ] ] ] < Hes[ father( Heap[ Poz[ val ] ] ) ] )
                percolate( Poz[ val ] );
            else
                sift( Poz[ val ] );
        }
        else
        {
            fout<<Hes[ Heap[ 1 ] ]<<'\n';
        }
    }


return 0;
}