#include<fstream>
#define MAXI 2000000000
using namespace std;

struct  nod
{
    int x,al_cat;
} h[400100];
int cat[200100];
int nrh;

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

void upheap(int i)
{
    while(h[i].x < h[i/2].x)
    {
        swap(h[i],h[i/2]);
        swap(cat[h[i].al_cat], cat[h[i/2].al_cat]);

        i = i/2;
    }
}

void downheap(int i)
{
    while(h[i].x > h[2*i].x || h[i].x>h[2*i+1].x)
    {
        int unde_idx = 2*i;
        if(h[2*i+1].x < h[2*i].x)
            unde_idx = 2*i+1;

        swap(h[i], h[unde_idx]);
        swap(cat[h[i].al_cat], cat[h[unde_idx].al_cat]);

        i = unde_idx;
    }
    return ;
}

void adauga_in_heap(int x, int al_cat)
{
    nod new_nod;
    new_nod.x = x;
    new_nod.al_cat = al_cat;
    h[++nrh] = new_nod;
    cat[new_nod.al_cat] = nrh;

    upheap(nrh);
}

void elimina_al(int x)
{
   int poz_heap = cat[x];

    h[poz_heap] = h[nrh];
    h[nrh].x = MAXI;h[nrh].al_cat = 0;
    cat[h[poz_heap].al_cat] = poz_heap;
    nrh--;
    if(poz_heap == 1)
    {
        downheap(poz_heap);
    }
    else if (h[poz_heap].x > h[2*poz_heap].x || h[poz_heap].x>h[2*poz_heap+1].x)
    {
        downheap(poz_heap);
    }
    else if(h[poz_heap].x < h[poz_heap/2].x)
    {
        upheap(poz_heap);
    }
}

int main()
{
    int n;
    f>>n;
    int nr_adaug  =0;

    h[0].x= 0;
    for(int i  =1; i<=400010; ++i)
        h[i].x = MAXI;

    for(int i = 1; i<=n; ++i)
    {
        int c = 0;
        f>>c;

        if(c == 1)
        {
            int x = 0;
            f>>x;
            adauga_in_heap(x, ++nr_adaug);
        }
        else if (c== 2)
        {
            int x = 0;
            f>>x;
            elimina_al(x);
        }
        else
        {
            g<<h[1].x<<"\n";
        }
    }

    return 0;
}