#include <fstream>

using namespace std;

const int Nmax = 200000;

struct hp{
    int elements[Nmax + 1];
    int loc[Nmax + 1];
    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[poz]] = poz;
            loc[elements[parent(poz)]] = parent(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, int poz){
        elements[len++] = val;
        loc[val] = poz;
        propagate_up(len - 1);
    }

    int extract_min(){
        int val = elements[1];
        elements[1] = elements[--len];
        propagate_down(1);
        return val;
    }

    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[poz_to_delete];
        update(poz, getMin());
        extract_min();
    }
};

int v[Nmax];
hp heap;

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

    int n, op, poz, pos_to_delete;

    fin >> n;

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

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

    return 0;
}