#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_initial[i] retine ordinea initiala a fiecarei valori => poz_initial[0] = valoare1
    ///elemente[i] e practic heap-ul
    ///size = lungimea heap-ului
    ///size_i = lungimea vect poz_initial
    Heap (){
        size = 0;
        elemente[0] = 0;
        poz_initial[0] = -1;
        size_i = 0;
    }

    ~Heap  () =  default;


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

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

    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;
    }

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

    }

    void heapfyDown (){
        int index = 0;
        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){
        elemente[size]=x;
        size++;
        poz_initial[size_i]=x;
        size_i++;
        heapfyUp();
    }

    void erase (int x){
        int pozitia = 0;
        for (int i = 0; i < 100001; i++)
            if (elemente[i] == poz_initial[x-1]){
                pozitia = i;
                break;
            }
        elemente[pozitia] = elemente[size-1];
        size--;
        heapfyDown();
    }

    int min (){
//        if(size==0){
//            cout << "EROARE";
//            return 0;
//        }
        return elemente[0];
    }
};

int main() {

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

    }

    for (int i =0; i<heap.size; i++)
        cout << heap.elemente[i] << " ";

    return 0;
}