#include <iostream>
#include <fstream>

using namespace std;

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

int N , poz [200001] , mare_heap [200001]  , v [200001] , lg_heap , lg_v  ;
// poz  =  pozitia fiecarui elem  in HEAP  , v = numerele citite in ordine

void swap ( int i , int j )
{
    int aux ;

    aux = mare_heap [i] ;
    mare_heap [i] = mare_heap [j] ;
    mare_heap [j] = aux ;

    poz [ mare_heap [i] ] = i ;
    poz [ mare_heap [j] ] = j ;

}

void heapup ( int  fiu ) // sau se mai numeste percolate .. se aplica la INSERARE ( inserez pe ultima poz disponibila in arbore si dupa ii gasesc locul)
{
    int tata ;
    if ( fiu > 1 )
        {
            tata = fiu >> 1 ;
            if ( v [ mare_heap [tata] ] > v [ mare_heap [fiu] ] )
                    swap ( fiu , tata ) , heapup ( fiu ) ;
        }
}

void heapdown ( int tata ) // sau se mai numeste SIFT  .. operatie ce actioneaza invers ca la percolate .. se aplica la stergere , poate fi aplicata impreuna cu PERCOLATE
{
    int fiu ;
    if ( 2 * tata + 1 <= lg_heap )
           if ( v [ mare_heap [ 2 * tata ] ] <= v [mare_heap [ 2 * tata + 1 ] ] )
                          fiu = 2 * tata ;
           else
                          fiu = 2 * tata + 1 ;
    else
          fiu = 2 * tata ;

    if ( tata <= lg_heap / 2 )
        if ( v [ mare_heap [fiu] ] < v [ mare_heap [tata] ] )
                     swap ( fiu , tata ) , heapdown ( tata ) ;

}

void InsertHeap ( int nd )
{
    ++ lg_heap ; ++ lg_v ;
    v [ lg_v ] = nd ; mare_heap [ lg_heap ] = lg_v ; poz [ lg_v ] = lg_heap ;
    heapup ( lg_heap ) ;
}

void DeleteHeap ( int ord )
{
    mare_heap [ ord ] = mare_heap [ lg_heap ] ;
    mare_heap [ lg_heap ] = 0 ;
    -- lg_heap ;
    heapup ( ord ) ;
    heapdown ( ord ) ;
}

int Minim ()
{
    return v [ mare_heap [1] ] ;
}
int main()
{
    fin >> N ;
    int a , b ;
    while ( N >= 1 )
    {
        fin >> a ;
        switch ( a )
        {
            case 1 : fin >> b ; InsertHeap (b) ; break ;
            case 2 : fin >> b ; DeleteHeap ( poz[b] ) ; break ;
            case 3 : fout << Minim () << " " ; break ;
        }
        -- N ;
    }

    return 0;
}