#include <iostream>
#include <fstream>

using namespace std;
ifstream fin("heapuri.in");
ofstream fout("heapuri.out");

class Heap{
public:
    int size, elemente[100001], poz_initial[100001], size_i, poz_heap[100001];


    static int parent_index (int child_index){
        return child_index/2;
    }
    static int left_child_index (int parent_index){
        return 2*parent_index;
    }
    static int right_child_index (int parent_index){
        return 2 * parent_index+1;
    }

    static bool has_parent (int index){
        return parent_index(index) >= 1;
    }

    bool has_left_child (int index) const {
        return left_child_index(index) <= size;
    }

    bool has_right_child (int index) const {
        return right_child_index(index) <= size;
    }

    int val_parent (int index) {
        return elemente[parent_index(index)];
    }

    int val_left_child (int index){
        return elemente[left_child_index(index)];
    }

    int val_right_child (int index){
        return elemente[right_child_index(index)];
    }


    void swap (int index1, int index2){
        int temp = elemente[index1];
        elemente[index1] = elemente[index2];
        elemente[index2] = temp;

        temp = poz_heap[elemente[index1]];
        poz_heap[elemente[index1]] = poz_heap[elemente[index2]];
        poz_heap[elemente[index2]] = temp;
    }

    void heapfyUp(){
        int index = size;
        while (has_parent(index) && val_parent(index) > elemente[index]){
            swap(parent_index(index), index);
            index = parent_index(index);
        }

    }

    void heapfyDown (){
        int index = 1;
        while (has_left_child(index)) {
            int smallerchild = left_child_index(index);
            if (has_right_child(index) && val_right_child(index) < val_left_child(index))
                smallerchild = right_child_index(index);

            if (elemente[index] < elemente[smallerchild])
            {
                break;
            } else{
                swap(index, smallerchild);
            }
            index = smallerchild;
        }
    }
    void add(int x){
        size++;
        elemente[size]=x;
        poz_heap[x] = size;
        size_i++;
        poz_initial[size_i]=x;
        heapfyUp();
    }

    void erase (int x){
        elemente[poz_heap[poz_initial[x]]]  = elemente[size-1];
        size--;
        poz_heap[poz_initial[x]] = 0;
        heapfyDown();
    }

    int min (){
        return elemente[1];
    }
};

int main() {

    int nr_op, cod_op, valoare;
    Heap heap;
    cin>>nr_op;
    for (int i=0; i<nr_op; i++){
        cin>>cod_op;
        if(cod_op==1){
            cin>>valoare;
            heap.add(valoare);
        }
        if(cod_op==2){
            cin>>valoare;
            heap.erase(valoare);
        }
        if(cod_op==3)
            cout << heap.min()<<endl;
    }


    return 0;
}