//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//*                                            Problema                                                 *
//*                                                                                                     *
//*                                                                                                     *
//*  Sa se realizeze un program in care, folosindu-se un vector de indici, sa se adauge/elimine         *
//* elemente dintr-un heap. Dupa executia cerintelor sa se pastreze structura de heap; daca se citeste  *
//* 1 - adaug + x - ce adaug                                                                            *
//* 2 - elimin + x - pozitia actuala din heap a valorii care se doreste a fi eliminata (x < N)          *
//*                                                                                                     *
//*                                                                                                     *
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

//
//Rezolvarea problemei de sus este baza problemei Heapuri de pe infoarena
//

#include <fstream>
#define maxn 50006

using namespace std;

int A[maxn], H[maxn], ORDER[maxn];
int N;
int NR;                         //numarul de locuri din vector
int L;                          //numarul de locuri din heap

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

void insert_heap ()
{
    int var = L;

    while (var / 2 && A[H[var/2]] > A[H[var]])
    {
        swap (H[var], H[var/2]);
        ORDER[H[var]] = var;
        ORDER[H[var/2]] = var / 2;
        var = var/2;
    }
}

void delete_heap (int pos)
{
    H[pos] = H[L];
    --L;

    if (pos / 2 && A[H[pos/2]] > A[H[pos]])
    {
        int var = pos;

        while (var / 2 && A[H[var/2]] > A[H[var]])
        {
            swap (H[var/2], H[var]);
            ORDER[H[var]] = var;
            ORDER[H[var/2]] = var / 2;
            var /= 2;
        }
    }
    else
    {
        int son;
        do
        {
            son = 0;

            if (pos * 2 <= L)
            {
                son = pos * 2;

                if (pos * 2 + 1 <= L && A[H[pos*2+1]] < A[H[son]])
                    ++son;
                if (A[H[son]] >= A[H[pos]])
                    son = 0;
            }
            if (son != 0)
            {
                swap (H[son], H[pos]);
                ORDER[H[son]] = son;
                ORDER[H[pos]] = pos;
                pos = son;
            }
        }while (son != 0);
    }
}

int main()
{
    int i, x, y;

    fin >> N;

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

        if (x == 1)
        {
            fin >> y;

            ++NR;
            ++L;
            A[NR] = y;
            H[L] = NR;
            ORDER[NR] = L;
            if(L > 1)
                insert_heap();
        }
        if (x == 2)
        {
            fin >> y;
           // ORDER[y] = 0;

            delete_heap(ORDER[y]);
        }
        if ( x == 3)
            fout << A[H[1]] << "\n";
    }

    /*for (i = 1; i <= NR; ++i)
        fout << ORDER[i] << " ";

    fout << "\n";

    for (i = 1; i <= L; ++i)
        fout << H[i] << " ";

    fout << "\n";

    for (i = 1; i <= L; ++i)
        fout << A[H[i]] << " ";*/

    return 0;

}