#include <fstream>
#include <vector>
#include <iostream>
using namespace std;

int nrOp, op;
vector<int> myHeap;
vector<int> temp;


void swap(int &a, int &b) {
    int aux = a;
    a = b;
    b = aux;
}


void urca(int poz){
    // pornesc cu ultima pozitie din vector
    // cat timp mai pot sa urc in heap
    while(poz){
        // tatal fata de nodul pozitie se afla la (poz-1)/2
        int tata = (poz - 1) / 2;
        // daca tatal este mai mare decat fiul atunci interchimb valorile
        if (myHeap[tata] > myHeap[poz]){
            // tatal vine in locul fiului si fiul in locul tatalui
            swap(myHeap[tata], myHeap[poz]);
            // noua pozitie din heap a elementului va fi pozitia veche a tatalui
            poz = tata;    
        }
        else
        // daca tatal este mai mic decat fiul atunci inseamna ca a ajuns la pozitia potrivita in heap
            break;
    }
}

void inserare(int elem){
    // int size = v.size();
    // temp.push_back(elem);
    // if (size == 0)
    //     v.push_back(elem);
    // else{
    //     v.push_back(elem);
    //     for (int i = size / 2 - 1; i >= 0; i--){
    //         heapify(v, i);
    //     }
    // }
    myHeap.push_back(elem);
    temp.push_back(elem);
    urca(myHeap.size() - 1);
}

void print_heap(){
    cout << "Heap:";
    for (int i = 0; i < myHeap.size(); i++)
        cout << myHeap[i] << " ";
    cout << endl;
}


void coboara(int poz){
    if (poz * 2 + 1 >= myHeap.size())
        return;
    int tata = myHeap[poz];
    int fiu_stang = myHeap[poz*2 + 1];
    if ((poz * 2 + 2 == myHeap.size()) || (fiu_stang < myHeap[poz * 2 + 2])){
        if (fiu_stang < tata){
            swap(myHeap[poz], myHeap[poz * 2 + 1]);
            //cout << "stang" << endl;
            //print_heap();
            coboara(poz * 2 + 1);
            return;
        }
        else{
            return;
        }
    }
    else{
            if (myHeap[poz * 2 + 2] < tata){
                print_heap();
                swap(myHeap[poz * 2 + 2], myHeap[poz]);
                //cout << "drept" << endl;
                //print_heap();
                coboara(poz * 2 + 2);
                return;
            }
            else
                return;
        }
}

int gaseste(int elem){
    for (int i = 0; i < myHeap.size(); i++)
        if (elem == myHeap[i])
            return i;
}


void elimina(int poz){
    int elem = temp[poz - 1];
    int poz_in_heap = gaseste(elem);
    //cout << "poz in heap al elem " << elem << " este " << poz_in_heap << endl;
    swap(myHeap[poz_in_heap], myHeap[myHeap.size() - 1]);
    myHeap.pop_back();
    //print_heap(); // pana aici e bine
    coboara(poz_in_heap);
    urca(poz_in_heap);
}

int peek(){
    return myHeap[0];
}



ifstream f("heapuri.in");
ofstream g("heapuri.out");

int main(){
    f >> nrOp;
    for (int i = 0; i < nrOp; i++){
        f >> op;
        switch (op){
            case 1: 
                    f >> op;
                    inserare(op);
                    break;
            case 2:
                    f >> op;
                    elimina(op);
                    break;
            case 3:
                    g << peek() << endl;
                    break;
        }
    }

    return 0;
}