#include <iostream>
#include <fstream>
#include <limits.h>
using namespace std;

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

int indici[200001];
int indici_heap[200001];

void afisare(int A[], int n)
{
    for(int i=1; i<=n; i++)
        cout<<A[i]<<" ";
    cout<<endl;
}

int parent ( int i )
{
    return i/2;
    //return i>>2;
}

int left ( int i )
{
    return 2*i;
    //return i<<2;
}

int right ( int i )
{
    return 2*i+1;
    //return (i<<2)|1;
}

//o implementare si mai buna era cu macro-uri

void min_heapify ( int A[], int i, int heap_size )
{
    int l, r, smallest;
    l = left(i);
    r = right(i);
    if( (l <= heap_size) && (A[l] > A[i]) )
        smallest = l;
    else
        smallest = i;
    if( (r <= heap_size) && (A[r] > A[smallest]) )
        smallest = r;
    if( smallest != i )
    {
        //cout<<"ce elem trebuie sa schimbe :"<<i<<" "<<smallest<<endl;
        swap(indici_heap[indici[i]], indici_heap[indici[smallest]]);
        swap(indici[i], indici[smallest]);
        swap( A[i], A[smallest] );
            /*cout<<"A: ";
            afisare(A, heap_size);
            cout<<"indici: ";
            afisare(indici, heap_size);
            cout<<"indici_heap: ";
            afisare(indici_heap, heap_size);
            cout<<endl;*/
        min_heapify( A, smallest, heap_size );
    }
}

/*
void build_min_heap (int A[], int length, int &heap_size)
//length = n
{
    heap_size = length;

    for( int i = length/2; i >= 1; i-- )
    {
        //cout<<"length: "<<length<<" "<<i<<endl;
        min_heapify(A, i, heap_size);
    }
}*/

/*
void HeapSort(int A[], int length, int &heap_size)
{
    build_min_heap(A, length, heap_size);

    /*cout<<endl<<"am terminat build"<<endl;

            cout<<"A: ";
            afisare(A, heap_size);
            cout<<"indici: ";
            afisare(indici, heap_size);
            cout<<"indici_heap: ";
            afisare(indici_heap, heap_size);
            cout<<endl;*/

    /*for(int i = length; i >= 2; i--)
    {

        //cout<<"i= "<<i<<endl;
        swap(indici_heap[indici[1]], indici_heap[indici[i]]);
        swap(indici[1], indici[i]);
        swap (A[1], A[i]);

            /*cout<<"A: ";
            afisare(A, heap_size);
            cout<<"indici: ";
            afisare(indici, heap_size);
            cout<<"indici_heap: ";
            afisare(indici_heap, heap_size);
            cout<<endl;*/
       /* heap_size--;
        min_heapify(A, 1, heap_size);
    }

}*/



void heap_minimum(int A[])
{
    fout<<A[1]<<'\n';
}

/*void heap_increase_key(int A[], int elem, int heap_size)
{
    A[heap_size] = elem;
    while(heap_size > 1 && A[parent(heap_size)]<A[heap_size])
    {
        swap(indici[heap_size], indici[parent(heap_size)]);

        swap(A[heap_size], A[parent(heap_size)]);
        heap_size = parent(heap_size);
    }
}*/

/*void min_heap_insert(int A[], int elem, int &heap_size)   //elem = key
{
    heap_size++;
    //A[heap_size] = INT_MAX;
    heap_increase_key(A, heap_size, elem);
}*/

int main()
{
    int A[200001];
    int heap_length=0, heap_size=0, i;
    //initial A.heap_size = 0 pt ca nu are niciun element si treptat va ajunge la n elem, adica == A.heap_length

    int n;
    fin>>n;
    int op, elem, index=0;
    for(i=1; i<=n; i++)
    {
        fin>>op;
        if(op == 3)
        {
            fout<<A[1]<<'\n';
            //heap_minimum(A);
            //continue;
        }
        if(op == 1)
        {
            //min_heap_insert(A, elem, heap_size); - nu mergea pt ca nu initializasem nicaieri indici[] si nici indici_heap[]
            fin>>elem;

            //heap - insert

            A[++heap_length] = elem;
            indici[heap_length] = ++index;
            indici_heap[heap_length] = index;

            /*cout<<"am ad elem"<<endl;
            cout<<"A: ";
            afisare(A, n);
            cout<<"indici: ";
            afisare(indici, n);
            cout<<"indici_heap: ";
            afisare(indici_heap, n);
            cout<<endl;*/

            //pt ca e deja sortat noi cand inseram doar mergem din tata in tata pana ii gasim pozitia

            int new_poz = heap_size;
            while( new_poz > 1 && A[parent(new_poz)] > A[new_poz])
            {
                swap(indici_heap[indici[new_poz]], indici_heap[indici[parent(new_poz)]]);
                swap(indici[new_poz], indici[parent(new_poz)]);
                swap (A[new_poz], A[parent(new_poz)]);
                new_poz = parent(new_poz);
            }
            ///HeapSort(A, heap_length, heap_size);
            //continue;
        }
        if(op == 2)
        {
            //stergere eficienta: pun la final, heap_size-- =>min_heapify
            fin>>elem;

            //delete ~ oarecum ca extract_min
            swap (A[heap_size], A[indici_heap[elem]]);
            swap(indici_heap[indici[heap_size]], indici_heap[indici[elem]]);
            swap(indici[heap_size], indici[elem]);

            //cout<<"sterge "<<elem<<endl;
            A[heap_size] = INT_MAX;
            heap_size--;
            min_heapify(A, 1, heap_size);
            //HeapSort(A, heap_length, heap_size);
            /*for(int j=1; j<=heap_length; j++)
                if(indici[j] == elem)
                {
                    A[j] = INT_MAX;
                    HeapSort(A, heap_length, heap_size);

                }*/
        }
    /*cout<<"A: ";
    afisare(A, n);
    cout<<"indici: ";
    afisare(indici, n);
    cout<<"indici_heap: ";
    afisare(indici_heap, n);
    cout<<endl;*/
    }

}