#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];
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 key);
void MinHeapInsert(int  (&H)[NMAX], int& n, int key);
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,nr);
        }
        else if(cod == 2)
        {
            fscanf(fin,"%d",&nr);
            Remove(H,N,ent[nr]);
        }
        else
        {
             fprintf(fout,"%d\n",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 = H[1];
    H[1] = H[n];
    n--;
    MinHeapify(H,n,1);
    return minim;
}

void Remove(int (&H)[NMAX], int &n, int key)
{
    FOR(i,1,n)
    {
        if(H[i] == key)
        {
            HeapDescreaseKey(H,i,-INF);
            ExtractMin(H,n);
            break;
        }
    }
}

void HeapDescreaseKey(int (&A)[NMAX], int i, int key)
{
    if( key > A[i])
    {
        cout<<"new key is bigger than current key";
    }
    A[i] = key;
    while(i > 1 && A[Parent(i)] > A[i])
    {
        swap(A[i], A[Parent(i)]);
        i = Parent(i);
    }
}

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

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 && H[l] < H[i] )
        smallest = l;
    else
        smallest = i;
    if( r <= n && H[r] < H[smallest] )
        smallest = r;

    if( smallest != i )
    {
        swap( H[i], H[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);
    }
}