#include <fstream>
#include <map>
#define NMAX 200008
///min-heap
using namespace std;
ifstream fin ("heapuri.in");
ofstream fout ("heapuri.out");

int n;
int H[NMAX], p[NMAX], elp[NMAX], cnt;
map <int, int> M;

void creare_comb(int H[], int& n);
void creare(int H[], int& n);
void afisare(int H[], int n);
void inserare(int H[], int& n, int x);
void combinare(int H[], int& n, int i);
int extrage_min(int H[], int& n);
void stergere(int H[], int& n, int x);


int main()
{
    ///creare(H, n);
    //creare_comb(H, n);
    //afisare(H, n);
    creare(H, n);
    return 0;
}

void creare(int H[], int& n)
{
    int nr;
    fin >> nr;
    n = 0;
    for (int i = 0; i < nr; i++)
    {
        int x, op;
        fin >> op;
        if (op == 1)
        {
            fin >> x;
            M[x] = ++cnt;
            elp[cnt] = x;
            inserare(H, n, x);
        }
        else if (op == 3)
            fout << H[1] << '\n';
        else
        {
            fin >> x;
            stergere(H, n, x);
        }
    }
}

void creare_comb(int H[], int& n)
{
    fin >> n;
    for (int i = 1; i <= n; i++) fin >> H[i];
    for (int i = n / 2; i > 0; i--) combinare(H, n, i);
}

void inserare(int H[], int& n, int x)
{
    int poz = n + 1, tpoz = poz / 2;
    while (tpoz > 0 && H[tpoz] > x)
    {
        H[poz] = H[tpoz];
        p[M[H[poz]]] = poz;
        poz = tpoz;
        tpoz = poz / 2;
    }
    H[poz] = x;
    p[M[x]] = poz;
    n++;
}

void combinare(int H[], int& n, int i)
///combin heap-urile corecte cu radacinile 2i si 2i+1 cu nodul i
{
    p[M[H[n]]] = i;
    H[i] = H[n--];
    int x = H[i], tata = i, fiu = 2*i;
    while (fiu <= n)
    {
        ///daca exista fiu drept si e mai mic
        if (fiu + 1 <= n && H[fiu+1] < H[fiu])  fiu++;
        if (H[fiu] < x)
        {
            H[tata] = H[fiu];
            p[M[H[fiu]]] = tata;
            tata = fiu;
            fiu = fiu * 2;
        }
        else
            break;
    }
    H[tata] = x;
    p[M[x]] = tata;
}

int extrage_min(int H[], int& n)
{
    int minim = H[1];
    H[1] = H[n--];
    combinare(H, n, 1);
    return minim;
}

void stergere(int H[], int& n, int x)
{
    combinare(H, n, p[M[elp[x]]]);
}

void afisare(int H[], int n)
{
    int i;
    for (i = 1; i <= n; i++)
        fout << H[i] << ' ';
    fout << '\n';
}