#include <iostream>
#include <fstream>
#include <vector>
#define val first
#define in second

using namespace std;

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

int N;

class heap{

    vector < pair< int, int > > H;
    vector < int > pos;

    inline int parent( int nod ){
        return ( nod - 1 ) >> 1;
    }
    inline int left( int nod ){
        return ( nod << 1 ) | 1;
    }
    inline int right( int nod ){
        return ( nod << 1 ) + 2;
    }

    void up_heap( int nod ){

        while( nod && H[nod].val < H[parent(nod)].val ){
            swap( H[nod], H[parent(nod)] );
            swap( pos[ H[nod].in ], pos[ H[parent(nod)].in ] );
            nod = parent(nod);
        }
    }

    void down_heap( int nod ){

        int son = -1;
        if( left(nod) < H.size() ){

            if( H[left(nod)].val < H[nod].val )
                son = left(nod);

            if( right(nod) < H.size() && H[right(nod)].val < H[nod].val && H[right(nod)].val < H[left(nod)].val )
                son = right(nod);
        }

        if( son != -1 ){
            swap( H[nod], H[son] );
            swap( pos[ H[nod].in ], pos[ H[son].in ] );
            down_heap( son );
        }
    }

public:

    int size(){
        return H.size();
    }

    int top(){
        return H[0].val;
    }

    void insert( int val ){

        H.push_back( {val, pos.size()} );
        pos.push_back( H.size()-1 );
        up_heap( H.size()-1 );
    }

    void del( int p ){

        int nod = pos[ p-1 ];

        swap( H[nod], H[ H.size()-1 ] );
        swap( pos[ H[ H.size()-1 ].in ], pos[ H[nod].in ] );
        H.pop_back();

        if( nod && H[nod].val < H[parent(nod)].val ) up_heap( nod );
        else down_heap( nod );
    }

}Heap;

void Solve()
{
    fin >> N;

    int task, x;
    for( int i = 1; i <= N; ++i )
    {
        fin >> task;

        if( task == 1 ){
            fin >> x;
            Heap.insert( x );
        }
        if( task == 2 ){
            fin >> x;
            Heap.del( x );
        }
        if( task == 3 ){
            fout << Heap.top() << '\n';
        }
    }
}
int main()
{
    Solve();
    return 0;
}