#include <fstream>
#define NMAX 200001
using namespace std;

int heap[NMAX], poz[NMAX], vec[NMAX];

void sift(int nr, int k) {
    int son, key = k;
    do {
        son = 0;
        if (k << 1 <= nr) {
            son = k << 1;
            if ((k << 1) + 1 <= nr && heap[k << 1] > heap[(k << 1) + 1]) {
                son = (k << 1) + 1;
            }
            if (heap[son] > heap[k]) {
                son = 0;
            }
        }
        if (son) {
            swap(heap[k], heap[son]);
            swap(vec[k], vec[son]);
            poz[son] = k;
            poz[k] = son;
            k >>= 1;
        }
    } while (son);
}

void percolate(int k) {
    int key = k;
    while (k > 1 && heap[k >> 1] > heap[k]) {
        swap(heap[k >> 1], heap[k]);
        swap(vec[k >> 1], vec[k]);
        poz[k >> 1] = k;
        k >>= 1;
    }
    poz[key] = k;
}

void cut(int &nr, int k) {
    heap[k] = heap[nr];
    vec[k] = vec[nr--];
    poz[k] = k;

    if (k > 1 && heap[k] < heap[k >> 1]) {
        percolate(k);
    } else {
        sift(nr, k);
    }
}

void heap_insert(int nr, int val) {
    heap[nr] = val;
    poz[nr] = nr;

    percolate(nr);
}

int main() {
    int i, n, op, nr = 0;

    ifstream in("heapuri.in");
    ofstream out("heapuri.out");
    in >> n;
    for (i = 0; i < n; ++i) {
        in >> op;
        switch (op) {
            case 1: in >> op;
                    vec[++nr] = nr;
                    heap_insert(nr, op);
                    break;
            case 2: in >> op;
                    cut(nr, poz[op]);
                    break;
            case 3: out << heap[1] << '\n';
        }
    }
    in.close();
    out.close();

    return 0;
}