#include <cstdio>
#include <iostream>
#include <limits>
#define FOR(i,a,b) for(int i = a; i <= b; i++)
#define NMAX 200005
using namespace std;

FILE* fin = fopen("heapuri.in","r");
FILE* fout = fopen("heapuri.out","w");

int ent[NMAX],H[NMAX],poz[NMAX];
int N,k;
const int INF = numeric_limits<int>::max();

int Parent(int i);
int Left(int i);
int Right(int i);
int Min(int H[NMAX]);
int ExtractMin(int (&H)[NMAX], int& n);
void HeapDescreaseKey(int (&A)[NMAX],int i, int ord);
void MinHeapInsert(int  (&H)[NMAX], int& n, int ord);
void MinHeapify(int (&H)[NMAX], int& n,int i);
void BuildMinHeap(int (&A)[NMAX], int& n);
void Heapsort(int (&A)[NMAX], int& n);
void Remove(int (&H)[NMAX], int &n, int key);

int main()
{
    int cod, nr,q;
    fscanf(fin,"%d",&q);
    H[0] = -INF;
    FOR(i,1,q)
    {
        fscanf(fin,"%d",&cod);
        if(cod == 1)
        {
            fscanf(fin,"%d",&nr);
            ent[++k] = nr;
            MinHeapInsert(H,N,k);
        }
        else if(cod == 2)
        {
            fscanf(fin,"%d",&nr);
            Remove(H,N,nr);
            //poz[nr] = -1;
        }
        else
        {
             fprintf(fout,"%d\n",ent[H[1]]);
        }
    }
    return 0;
}

int Parent(int i)
{
    return i >> 1;
}

int Left(int i)
{
    return i << 1;
}

int Right(int i)
{
    return (i << 1) + 1;
}


int Min(int H[NMAX])
{
    return H[1];
}

int ExtractMin(int (&H)[NMAX], int& n)
{
    if(n < 1)
    {
        cout<<"Heap underflow";
    }
    int minim = ent[H[1]];
    poz[H[1]] = 0;
    H[1] = H[n--];
    poz[H[1]] = 1;
    MinHeapify(H,n,1);
    return minim;
}

void Remove(int (&H)[NMAX], int &n, int p)
{
    ent[p] = -INF;
    HeapDescreaseKey(H, poz[p], p);

    ExtractMin(H,n);
}

void HeapDescreaseKey(int (&H)[NMAX], int i, int ord)
{
    H[i] = ord;
    poz[ord] = i;

    while(i > 1 && ent[H[Parent(i)]] > ent[H[i]])
    {
        swap(H[i], H[Parent(i)]);
        poz[H[i]] = i;
        poz[H[Parent(i)]] = Parent(i);
        i = Parent(i);
    }

}

void MinHeapInsert(int (&H)[NMAX], int& n, int ord)
{
    n++;
    H[n] = INF;
    poz[ord] = n;
    HeapDescreaseKey(H, n, ord);
}

void MinHeapify(int (&H)[NMAX], int& n,int i) //assumes Left(i) & Right(i) are heaps, but i not quite
{
    int smallest, l = Left(i), r = Right(i);

    if( l <= n && ent[H[l]] < ent[H[i]] )
        smallest = l;
    else
        smallest = i;
    if( r <= n && ent[H[r]] < ent[H[smallest]] )
        smallest = r;

    if( smallest != i )
    {
        swap( H[i], H[smallest] );
        poz[H[i]] = i;
        poz[H[smallest]] = smallest;
        MinHeapify( H, n, smallest );
    }
}
/*
void BuildMinHeap(int (&A)[NMAX], int& n)
{
    for(int i = A[n/2]; i >= 1; i--)
        MinHeapify(A,n,i);
}

void Heapsort(int (&A)[NMAX], int& n)
{
    BuildMinHeap(A,n);
    for( int i = n; i >= 2; i-- )
    {
        swap(A[i],A[i]);
        n--;
        MinHeapify(A,n,1);
    }
}
*/