#include <iostream>
#include<bits/stdc++.h>
#include <fstream>

using namespace std;

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

const int oo=(1<<31)-1;


void push(int);
int LChild(int);
int RChild(int);
int get();
void climb_up(int);
void climb_down(int);
void pop(int);


vector<int> heap(1,(1<<31));
vector<int> NrOrdOf(1,0);
vector<int> PositionInHeap(1,0);
int nrOrd=1;

int main()
{
    int n,x,cod;
    f>>n;
    for(;n;n--)
    {
        f>>cod;
        if(cod==1)
        {
            f>>x;
            push(x);
        }
        else if(cod==2)
        {
            ///for(auto it:PositionInHeap) g<<it<<' ';
            ///g<<endl;
            f>>x;
            pop(PositionInHeap[x]);
        }
        else if(cod==3)
        {
            g<<get()<<endl;
        }
    }
    return 0;
}


void push(int x)
{
    heap.push_back(x);
    int k=heap.size()-1;
    PositionInHeap.push_back(k);
    NrOrdOf.push_back(nrOrd);
    nrOrd++;
    climb_up(k);

}

int LChild(int i)
{
    if(i*2<=heap.size()-1)
    return heap[i*2];
    return oo;
}

int RChild(int i)
{
    if(i*2+1<=heap.size()-1)
        return heap[i*2+1];
    return oo;
}

int get()
{
    return heap[1];
}

void climb_up(int k)
{
    while(heap[k/2]>heap[k])
    {
        swap(heap[k/2],heap[k]);
        swap(PositionInHeap[NrOrdOf[k/2]],PositionInHeap[NrOrdOf[k]]);
        swap(NrOrdOf[k/2],NrOrdOf[k]);

        k/=2;
    }
}

void climb_down(int k=1)
{
    while(RChild(k)<heap[k] || LChild(k)<heap[k])
    {
        if(RChild(k)<LChild(k))
            {
                swap(heap[k*2+1],heap[k]);
                swap(PositionInHeap[NrOrdOf[k]],PositionInHeap[NrOrdOf[k*2+1]]);
                swap(NrOrdOf[k*2+1],NrOrdOf[k]);

                k=k*2+1;
            }
        else
            {
                swap(heap[k*2],heap[k]);
                swap(PositionInHeap[NrOrdOf[k]],PositionInHeap[NrOrdOf[k*2]]);
                swap(NrOrdOf[k*2],NrOrdOf[k]);
                k=k*2;
            }
    }
}

void pop(int i)
{
    heap[i]=heap[heap.size()-1];
    heap.pop_back();
    NrOrdOf.pop_back();
    if(heap[i/2]>heap[i])climb_up(i);
    else climb_down(i);
}