#include <fstream>
#include <vector>

using namespace std;

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

typedef vector<int> Heap;
unordered_map<int, int> original;            // original[poz_heap] = poz_initiala
unordered_map<int, int> pos_original;        // pos_original[pozitie_initiala] = pozitia in heap

inline int parent(int node) {
    return node / 2;
}

inline int left_son(int node) {
    return node * 2;
}

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

inline int min(const Heap &h) {
    return h[1];
}

void swap_with_pos(Heap &h, int i, int j) {
    swap(h[i], h[j]);
    swap(original[i], original[j]);
    pos_original[original[i]] = i;        // actualizam maparea inversa
    pos_original[original[j]] = j;
}

void downheapify(Heap &h, int n, int node) {
    int son = 0;
    do {
        son = 0;
        if (left_son(node) <= n) {
            son = left_son(node); // fiul mai mic e in stanga
            if (right_son(node) <= n && h[right_son(node)] < h[left_son(node)]) son = right_son(node); // fiul mai mic e in dreapta
            if (h[son] >= h[node]) son = 0; // fiul cel mai mic e mai mic decat parintele, s-a atins structura de heap
        }
        if (son) {
            swap_with_pos(h, node, son);
            node = son;
        }
    } while (son);
}

void upheapify(Heap &h, int node) {
    int val = h[node];
    int orig = original[node];
    while (node > 1 && val < h[parent(node)]) {
        h[node] = h[parent(node)]; // se copiaza valoarea mai mare si se pune pe son
        original[node] = original[parent(node)];
        pos_original[original[node]] = node;
        node = parent(node); // se urca in parent
    }
    h[node] = val; // se pune valoarea initiala unde trebuie
    original[node] = orig;
    pos_original[orig] = node;
}

void make_heap(Heap &h, int n) {
    for (int i = n / 2 ; i >= 1 ; --i) {
        downheapify(h, n, i);
    }
}

void eliminate(Heap &h, int &n, int node) {
    int last_val = h[n];
    int last_orig = original[n];

    pos_original.erase(original[node]);

    h[node] = last_val;
    original[node] = last_orig;
    pos_original[last_orig] = node;

    h.pop_back();
    original.erase(n);
    --n;

    if (node > 1 && h[node] < h[parent(node)]) upheapify(h, node);
    else downheapify(h, n, node);
}

void insert(Heap &h, int &n, int elem, int input_pos) {
    h.push_back(elem);
    ++n;
    original[n] = input_pos;
    pos_original[input_pos] = n;
    upheapify(h, n);
}

Heap heap(1, 0);

int main() {
    int n; cin >> n;
    int sz = 0;
    int cin_pos = 1;
    while (n--) {
        int cod; cin >> cod;
        if (cod == 1) {
            int element_to_insert; cin >> element_to_insert;
            insert(heap, sz, element_to_insert, cin_pos);
            cin_pos++;
        }
        if (cod == 2) {
            int cin_pos_to_erase; cin >> cin_pos_to_erase;
            eliminate(heap, sz, pos_original[cin_pos_to_erase]);
        }
        if (cod == 3) {
            cout << min(heap) << "\n";
        }
    }
    return 0;
}