#include <fstream>
#include <unordered_map>

using namespace std;

const int Nmax = 200000;

int v[Nmax + 1];

struct hp{
    int elements[Nmax + 1];
    unordered_map<int, int> loc;
    int len = 1;

    inline int parent(int poz){
        return poz / 2;
    }
    inline int left_child(int poz){
        return poz * 2;
    }
    inline int right_child(int poz){
        return poz * 2 + 1;
    }

    void propagate_up(int poz){
        while(poz > 1 && elements[parent(poz)] > elements[poz]){
            swap(elements[parent(poz)], elements[poz]);

            loc[elements[parent(poz)]] = parent(poz);
            loc[elements[poz]] = poz;

            poz = parent(poz);
        }
    }
    void propagate_down(int poz){
        int smallest = poz;
        int left = left_child(poz);
        int right = right_child(poz);

        if(left < len && elements[left] < elements[smallest]){
            smallest = left;
        }
        if(right < len && elements[right] < elements[smallest]){
            smallest = right;
        }

        if(smallest != poz){
            swap(elements[poz], elements[smallest]);

            loc[elements[poz]] = poz;
            loc[elements[smallest]] = smallest;

            propagate_down(smallest);
        }
    }

    void add(int val){
        elements[len] = val;
        loc[val] = len;
        propagate_up(len);
        len++;
    }

    void extract_min(){
        elements[1] = elements[--len];
        elements[len] = 0;
        propagate_down(1);
    }

    int getMin(){
        return elements[1];
    }

    void update(int poz, int val){
        int old_val = elements[poz];

        elements[poz] = val;
        if(old_val > val){
            propagate_up(poz);
        }
        else{
            propagate_down(poz);
        }

    }

    void del(int poz_to_delete){
        int poz = loc[v[poz_to_delete]];
        update(poz, getMin());
        extract_min();
    }
};

hp heap;

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

    int n, op, poz, pos_to_delete;

    fin >> n;

    poz = 1;
    while(n--){
        fin >> op;

        if(op == 1){
            fin >> v[poz];
            heap.add(v[poz]);
            poz++;
        }
        else if(op == 2){
            fin >> pos_to_delete;
            heap.del(pos_to_delete);
        }
        else{
            fout << heap.getMin() << '\n';
        }
    }

    return 0;
}