//#include <iostream>
#include <fstream>

using namespace std;

ifstream cin("heapuri.in");
ofstream cout("heapuri.out");


const int N = 2e5;
int queries, heap_size = 0, n = 0;
int heap[N+1], v[N+1], poz[N+1];
/// min heap


int left_son(int node)
{
    return node * 2;
}
int right_son(int node)
{
    return node * 2 + 1;
}
int daddy(int node)
{
    return node / 2;
}

void sift(int node)
{
    int the_one;
    do
    {
        the_one = 0;
        if (left_son(node) <= heap_size)
        {
            the_one = left_son(node);
            if (right_son(node) <= heap_size && v[ heap[right_son(node)] ] < v[ heap[left_son(node)] ])
                the_one = right_son(node);
            if (v[ heap[node] ] <= v[ heap[the_one] ])
                the_one = 0;
        }
        if (the_one)
        {
            swap(heap[node], heap[the_one]);
            poz[ heap[node] ] = node, poz[ heap[the_one] ] = the_one;
            node = the_one;
        }
    }
    while (the_one);
}

void percolate(int node)
{
    while (node > 1 && v[ heap[node] ] < v[ heap[daddy(node)] ])
    {
        swap(heap[node], heap[daddy(node)]);
        poz[ heap[node] ] = node, poz[ heap[daddy(node)] ] = daddy(node);
        node = daddy(node);
    }
}

void insert(int ind)
{
    heap[++heap_size] = ind;
    poz[ind] = heap_size;
    percolate(heap_size);
}

void erase(int node)
{
    heap[node] = heap[heap_size];
    poz[ heap[heap_size] ] = node;
    heap_size--;
    if (node > 1 && v[ heap[node] ] < v[ heap[daddy(node)] ])
        percolate(node);
    else
        sift(node);
}


int main()
{
    cin >> queries;

    for (int q = 1; q <= queries; q++)
    {
        int cod;
        cin >> cod;

        if (cod == 1)
        {
            int x;
            cin >> x;
            v[++n] = x;
            insert(n);
        }
        else if (cod == 2)
        {
            int x;
            cin >> x;
            erase(poz[x]);
        }
        else
        {
            cout << v[ heap[1] ] << '\n';
        }
    }

    return 0;
}