#include <fstream>

using namespace std;

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

int n, t, nr, k, x, op, ad, poz[200002];

struct heap
{
    int val, timp;
} h[200002];

void percolate(int k)
{
    while(h[k].val < h[k / 2].val && k != 1)
    {
        swap(poz[h[k].timp],poz[h[k / 2].timp]);
        swap(h[k], h[k / 2]);
        k /= 2;
    }
}

void sift(int k)
{
    while((2 * k) <= n)
    {
        if(2 * k + 1 <= n)
        {
            if(h[k].val < min(h[2 * k].val, h[2 * k + 1].val)) break;
            if(h[2 * k].val < h[2 * k + 1].val )
            {
                swap(poz[h[k].timp],poz[h[2 * k].timp]);
                swap(h[k], h[2 * k]);
                k *= 2;
            }
            else
            {
                swap(poz[h[k].timp],poz[h[2 * k + 1].timp]);
                swap(h[k], h[2 * k + 1]);
                k = 2 * k + 1;
            }
        }
        else
        {
            if(h[k].val > h[2 * k].val)
            {
                swap(poz[h[k].timp],poz[h[2 * k].timp]);
                swap(h[k], h[2 * k]);
                k *= 2;
            }
            else break;
        }

    }
}

int main()
{
    f>>nr;
    for(t = 1; t <= nr; ++ t)
    {
        f>>op;
        if(op == 1)
        {
            ++ ad;
            f>>h[++n].val;
            h[n].timp = ad;
            poz[ad] = n;
            percolate(n);
        }
        else if(op == 2)
        {
            f>>x;
            k = poz[x];
            swap(poz[h[k].timp], poz[h[n].timp]);
            swap(h[k], h[n]);
            -- n;
            if(h[k].val < h[k / 2].val && (k != 1))
                percolate(k);
            else
            {
                if(2 * k + 1 <= n)
                {
                    if(h[k].val > min(h[2 * k + 1].val, h[2 * k].val))
                        sift(k);
                }
                else if(h[k].val > h[2 * k].val)
                    sift(k);

            }
        }
        else g<<h[1].val<<'\n';

    }
    return 0;
}