#include <bits/stdc++.h>

using namespace std;

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

void usain_bolt()
{
    ios::sync_with_stdio(false);
    fin.tie(0);
}

const int N = 2e5 + 5;

int sz = 0, order[N], pos[N], val[N], a[N];

int dad(int k)
{
    return k / 2;
}

int left_son(int k)
{
    return 2 * k;
}

int right_son(int k)
{
    return 2 * k + 1;
}

void down(int k)
{
    int son;
    do {
        son = 0;
        if(left_son(k) <= sz) {
            son = left_son(k);
            if(right_son(k) <= sz && val[a[right_son(k)]] < val[a[left_son(k)]]) {
                son = right_son(k);
            }
            if(val[a[son]] >= val[a[k]]) {
                son = 0;
            }
        }
        if(son) {
            swap(a[k], a[son]);
            swap(pos[a[k]], pos[a[son]]);
            k = son;
        }
    }
    while(son);
}

void up(int k)
{
    int nr = val[a[k]];
    int ord = a[k];
    while(k > 1 && nr < val[a[dad(k)]]) {
        a[k] = a[dad(k)];
        pos[a[k]] = k;
        k = dad(k);
    }
    a[k] = ord;
    pos[a[k]] = k;
    val[a[k]] = nr;
}

void heap_add(int k)
{
    a[++sz] = k;
    pos[a[sz]] = sz;
    up(sz);
}

void heap_delete(int k)
{
    pos[a[sz]] = pos[k];
    a[pos[k]] = a[sz];
    --sz;
    if(k > 1 && val[a[pos[k]]] < val[a[dad(pos[k])]]) {
        up(pos[k]);
    }
    else {
        down(pos[k]);
    }
}

int main()
{
    usain_bolt();

    int n;
    fin >> n;
    for(int i = 1; i <= n; ++i) {
        int type;

        fin >> type;
        if(type == 1) {
            int x;

            fin >> x;
            val[++order[0]] = x;
            heap_add(order[0]);

        }
        else if(type == 2) {
            int x;

            fin >> x;
            heap_delete(x);
        }
        else {
             fout << val[a[1]] << "\n";
        }
    }
    return 0;
}