#include<fstream>
#include<algorithm>
using namespace std;

#define NMAX 200002

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

int N;
int v[NMAX], Heap[NMAX], poz[NMAX];

// v[] = sirul initial de elemente
// Heap[] = min-heap (tinem pozitiile, nu elementele)
// poz[x] = cine e al x-lea element din sirul initial

void upHeap(int nod) {

    int tata = (nod >> 1);
    if (!tata)
        return;

    if (v[Heap[tata]] > v[Heap[nod]]) {

        swap(poz[Heap[tata]], poz[Heap[nod]]);
        swap(Heap[tata], Heap[nod]);

        upHeap(tata);
    }
}

void downHeap(int nod) {

    int fiu = (nod << 1);

    if (fiu > N)
        return;

    if (fiu < N && v[Heap[fiu + 1]] < v[Heap[fiu]])
        fiu++;

    if (v[Heap[nod]] > v[Heap[fiu]]) {

        swap(poz[Heap[nod]], poz[Heap[fiu]]);
        swap(Heap[nod], Heap[fiu]);

        downHeap(fiu);
    }
}

int main() {

    int T, i = 0;

    fin >> T;

    while (T--) {

        int op;
        fin >> op;

        if (op == 1) { //inserare

            fin >> v[++i];
            Heap[++N] = i;
            poz[i] = N;
            upHeap(N);
        }
        else if (op == 2) { //stergere

            int x;
            fin >> x;

            poz[Heap[N]] = poz[x];
            Heap[poz[x]] = Heap[N];
            N--;
            downHeap(poz[x]);
        }
        else
            fout << v[Heap[1]] << "\n"; //afisare
    }

    return 0;
}