#include <algorithm>
#include <fstream>
#include <vector>

#define parent(pos) ((pos - 1) / 2)
#define left_child(pos) (2 * pos + 1)
#define right_child(pos) (2 * pos + 2)
#define is_less(i, j) (data[heap[i]] < data[heap[j]])

using namespace std;

typedef int heap_t;
const int MAXN = 200001;

struct Heap {
    heap_t data[MAXN];
    int heap[MAXN], pos_heap[MAXN], data_size, heap_size;
    
    Heap() : data_size(0), heap_size(0) {}
    
    void swaph(int i, int j) {
        swap(heap[i], heap[j]);
        pos_heap[heap[i]] = i;
        pos_heap[heap[j]] = j;
    }
    
    void up(int i) {
        for (int p = parent(i); p != i && is_less(i, p); i = p, p = parent(p))
            swaph(i, p);
    }
    
    void down(int i) {
        int next;
        while (true) {
            if (left_child(i) < heap_size)
                next = left_child(i);
            else return;
            if (right_child(i) < heap_size && is_less(right_child(i), next))
                next = right_child(i);
            
            if (! is_less(next, i)) return;
            
            swaph(i, next);
            i = next;
        }
    }
    
    void insert(int x) {
        data[data_size] = x;
        pos_heap[data_size] = heap_size;
        heap[heap_size] = data_size;
        
        data_size++;
        up(heap_size++);
    }
    
    void remove(int i) {
        i = pos_heap[i];
        swaph(i, --heap_size);
        down(i);
    }
    
    int top() { return data[heap[0]]; }
} H;

int main() {
    ifstream fin("heapuri.in");
    ofstream fout("heapuri.out");
    
    int q, op, x, i;
    
    for (fin >> q; q; --q) {
        fin >> op;
        if (op == 1) {
            fin >> x;
            H.insert(x);
        }
        else if (op == 2) {
            fin >> i;
            H.remove(i-1);
        }
        else
            fout << H.top() << endl;
    }
    
    return 0;
}