#include <iostream>
#include <fstream>
#include <algorithm>
#define NMAX 200001

using namespace std;

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

typedef int Heap[NMAX];
Heap H, Ord;
int order[NMAX], n, many = 0;
int Heap_dim = 0;

void sift(Heap H, int N, int k)
{
    int son;
    do
    {
        son = 0;
        if (2 * k <= N)
        {
            son = 2 * k;
            if (2 * k + 1 <= N && H[son] > H[2 * k + 1])
                son = 2 * k + 1;
            if (H[k] <= H[son])
                son = 0;
        }
        if (son)
        {
            swap(H[k], H[son]);
            swap(Ord[k], Ord[son]);
            swap(order[Ord[k]], order[Ord[son]]);
            k = son;
        }
    }while(son);
}

void percolate(Heap H, int N, int k)
{
    int key = H[k];
    int ord = Ord[k];
    while (k > 1 && H[k / 2] > key)
    {
        H[k] = H[k / 2];
        Ord[k] = Ord[k / 2];
        order[Ord[k]] = k;
        k = k / 2;
    }
    H[k] = key;
    Ord[k] = ord;
    order[ord] = k;
}

void cut(Heap H, int &N, int k)
{
    swap(H[k], H[N]);
    swap(Ord[k], Ord[N]);
    swap(order[Ord[k]], order[Ord[N]]);
    N--;
    if (k > 1 && H[k] < H[k / 2])
        percolate(H, N, k);
    else
        sift(H, N, k);
}

void insert(Heap H, int &N, int key)
{
    H[++N] = key;
    Ord[N] = many;
    percolate(H, N, N);
}

int main()
{
    in >> n;
    int op, key;
    for (int i = 1; i <= n; i++)
    {
        in >> op;
        switch (op)
        {
            case 1:
                {
                    in >> key;
                    order[++many] = Heap_dim + 1;
                    insert(H, Heap_dim, key);
                    break;
                }
            case 2:
                {
                    in >> key;
                    cut(H, Heap_dim, order[key]);
                    break;
                }
            case 3:
                {
                    out << H[1] << "\n";
                    break;
                }
        }
    }
    in.close();
    out.close();
    return 0;
}