#include <iostream>
#include <fstream>
#include <limits.h>
using namespace std;

ifstream fin("heapuri.in");
ofstream fout("heapuri.out");

int indici[200001];

int parent ( int i )
{
    return i/2;
    //return i>>2;
}

int left ( int i )
{
    return 2*i;
    //return i<<2;
}

int right ( int i )
{
    return 2*i+1;
    //return (i<<2)|1;
}

//o implementare si mai buna era cu macro-uri

void min_heapify ( int A[], int i, int heap_size )
{
    int l, r, smallest;
    l = left(i);
    r = right(i);
    if( (l <= heap_size) && (A[l] > A[i]) )
        smallest = l;
    else
        smallest = i;
    if( (r <= heap_size) && (A[r] > A[smallest]) )
        smallest = r;
    if( smallest != i )
    {
        swap(indici[i], indici[smallest]);
        swap( A[i], A[smallest] );
        min_heapify( A, smallest, heap_size );
    }
}

void build_min_heap (int A[], int length, int &heap_size)
//length = n
{
    heap_size = length;
    for( int i = length/2; i >= 1; i-- )
        min_heapify(A, i, heap_size);
}

void HeapSort(int A[], int length, int &heap_size)
{
    build_min_heap(A, length, heap_size);
    for(int i = length; i >= 2; i--)
    {
        swap(indici[1], indici[i]);
        swap (A[1], A[i]);
        heap_size--;
        min_heapify(A, 1, heap_size);
    }

}

void afisare(int A[], int n)
{
    for(int i=1; i<=n; i++)
        fout<<A[i]<<" ";
}

int main()
{
    int A[200001];
    int heap_length=0, heap_size=0, i;
    //initial A.heap_size = 0 pt ca nu are niciun element si treptat va ajunge la n elem, adica == A.heap_length

    int n;
    fin>>n;
    int op, elem, index=0;
    for(i=1; i<=n; i++)
    {
        fin>>op;
        if(op == 3)
        {
            fout<<A[1]<<endl;
            continue;
        }
        if(op == 1)
        {
            fin>>elem;
            A[++heap_length] = elem;
            indici[heap_length] = ++index;
            HeapSort(A, heap_length, heap_size);
            continue;
        }
        if(op == 2)
        {
            fin>>elem;
            for(int j=1; j<=heap_length; j++)
                if(indici[j] == elem)
                {
                    A[j] = INT_MAX;
                    HeapSort(A, heap_length, heap_size);

                }
        }
    }
    //afisare(A, n);
}