#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);


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, ok;
        fin >> op;
        if (op == 1)
        {
            fin >> x;
            if (x == 10405)
                int ok2 = 1;
            M[x] = ++cnt;
            elp[cnt] = x;
            p[cnt] = n+1;
            inserare(H, n, x);
        }
        else if (op == 3)
        {
            fout << H[1] << '\n';
        }
        else
        {
            if (i == 373)
                int ok2 = 1;
            fin >> x;
            combinare(H, n, p[M[elp[x]]]);
        }
        for (int j = 2; j <= n; j++)
            if (H[j] < H[j/2])
                ok = M[314];
    }
}

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, t = i/2;
    x = H[tata];
    if (t > 0 && H[t] > x)
    {
        while (t > 0 && H[t] > x)
        {
            H[tata] = H[t];
            p[M[H[tata]]] = tata;
            tata = t;
            t = tata/2;
        }
        H[tata] = x;
        p[M[x]] = tata;
        return;
    }
    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 afisare(int H[], int n)
{
    int i;
    for (i = 1; i <= n; i++)
        fout << H[i] << ' ';
    fout << '\n';
}