#include <iostream>
#include <fstream>

using namespace std;

const int N = 200010;

int dim, m, v[N], w[N], poz[N];
//
//struct Tip
//{
//    int info, poz;
//} v[N];


//
//void heapify( int root)
//{
//    //Determinam minimul dintre root si cei 2 fii ai sai
//    int minimum = root;
//    int lc = 2*root ;
//    int rc = 2*root + 1;
//
//    if (lc < dim && v[lc].info < v[minimum].info)
//        minimum = lc;
//
//    if (rc < dim && v[rc].info < v[minimum].info)
//        minimum = rc;
//
//    //Daca unul dintre cei 2 fii contine o valoarea mai mare decat cea din radacina,
//    //interschimbam cele doua valori si refacem structura de heap a subarborelui fiului respectiv
//    if (minimum != root)
//    {
//        swap(v[root], v[minimum]);
//        heapify( minimum);
//    }
//}
//
////Functie care sorteaza un tablou v format din n elemente
//void heapSort( )
//{
//    //Se construieste heap-ul initial
//    for (int i = dim/2-1; i >= 0; i--)
//        heapify(i);
//
//    //De n ori efectuam urmatoarele operatii
//    for (int i = dim-1; i >= 0; i--)
//    {
//        //Interschimbam valoarea minima din heap (v[0])
//        //cu ultima valoare din subarborele curemt (v[i])
//        swap(v[0], v[i]);
//
//        //Refacem structura de heap a arborelui redus
//        heapify( 0);
//    }
//}

void minheap (int n)
{
    while (v[n] < v[n / 2] && (n / 2) >= 1)
    {
        swap(v[n], v[n / 2]);
        w[poz[n]] = n / 2;
        w[poz[n/2]] = n;
        swap(poz[n], poz[n / 2]);
        n /= 2;
    }
}

void interschimb ( int &x, int &i)
{
    swap(v[i], v[x]);
    w[poz[i]] = x;
    w[poz[x]] = i;
    swap(poz[i], poz[x]);
    i = x;
}

void elimin (int i)
{
    int x;
    w[poz[i]] = dim;
    w[poz[dim]] = i;
    swap(v[i], v[dim]);
    swap(poz[i], poz[dim]);

    minheap(i);

    while((v[i] >= v[i * 2] && (i * 2) < dim) || (v[i] >= v[i * 2 + 1] && (i * 2 + 1) < dim))
    {
        bool a ,b;
        a = (v[i * 2] <= v[i * 2 + 1] && (i * 2) < dim);
        b = (v[i * 2] >= v[i * 2 + 1] && (i * 2 + 1) < dim);
        x = 2 * i;
        if(a)
            interschimb(x , i);
        else
        {
            if (b)
            {
                x++;
                interschimb(x, i);
            }
            else
            {
                if( x < dim)
                    interschimb ( x, i );
                    return ;
            }
        }
    }
}


void adaugare( int x )
{
    dim++;
    m++;
    w[m] = dim;
    poz[dim] = m;
    v[dim] = x;
    minheap(dim);
}

void stergere ( int x)
{
/// elimin elementul
    elimin ( w[x] );
    dim --;
//    int i, j, a;
//    x--;
//    for ( j = 0 ; j < dim ; j++)
//        if(v[j].poz == x)
//        {
//            i = j;
//            break;
//        }
//    dim --;
//    for ( ; i < dim; i++ )
//        v[i] = v[i+1];
//    heapify( 0 );
    //afis ();
}
//
//int minim()
//{
//    heapSort();
//    return v[0].info;
//}

int main()
{
    ifstream in("heapuri.in");
    ofstream out( "heapuri.out");

    int n, op, i, x;

    in >> n;
    for (i = 0; i < n; i++)
    {
        in >> op ;
        if ( op == 3)
        {
            out << v[1] << "\n";
        }
        else
        {
            in >> x;
            if ( op == 1)
                adaugare ( x );
            else
                stergere ( x );
        }
    }

    in.close();
    out.close();

    return 0;
}