#include <fstream>
#include <iostream>
#include <vector>
using namespace std;

class Node
{
public:
    int Key, Order;
    Node () { Key = Order = 0; }
    Node (int key, int o) { Key = key; Order = o; }

    bool operator< (const Node b)
    {
        return (Key < b.Key);
    }

    bool operator> (const Node b)
    {
        return (Key > b.Key);
    }
};

vector<Node> Heap;
vector<int> Order;
int size;

inline int MinChild (int node)
{
    if (node<1 || node>size || (2*node)>size) return -1;
    if ((2*node+1) > size) return 2*node;

    return (Heap[2*node] < Heap[2*node+1]) ? (2*node) : (2*node+1);
}


void Push(int key)
{
    Heap.push_back(Node(key, Order.size()));
    Order.push_back(++size);

    int node = size;

    while (node>1 && Heap[node/2] > Heap[node])
    {
        swap(Order[Heap[node].Order], Order[Heap[node/2].Order]);
        swap(Heap[node], Heap[node/2]);
        node /= 2;
    }
}


void Pop (int heap_index)
{
    int ma;

    swap (Heap[heap_index],Heap[size]);
    swap (Order[Heap[heap_index].Order], Order[Heap[size].Order]);
    size--;
    Heap.resize(Heap.size()-1);

    if (heap_index > 1 && Heap[heap_index] < Heap[heap_index/2])
    {
        while (heap_index>1 && Heap[heap_index/2] > Heap[heap_index])
        {
            swap(Order[Heap[heap_index].Order], Order[Heap[heap_index/2].Order]);
            swap(Heap[heap_index], Heap[heap_index/2]);
            heap_index /= 2;
        }
    }

    else
    {
        do
        {
            ma = MinChild(heap_index);
            if (ma>0 && Heap[heap_index] < Heap[ma]) ma = -1;

            if (ma > 0)
            {
                swap(Order[Heap[ma].Order], Order[Heap[heap_index].Order]);
                swap(Heap[ma], Heap[heap_index]);
                heap_index=ma;
            }
        } while (ma > 0);
    }
}



int main()
{
    ifstream in ("heapuri.in");
    ofstream out ("heapuri.out");

    Heap.push_back(Node(-1,-1));
    Order.push_back(-1);

    //for (unsigned a=0; a<0x3fffffff; a++);

    int N, op, param;

    for (in>>N; N > 0; N--)
    {
        in>>op;

        switch (op)
        {
            case 1: in>>param; Push(param);
                break;

            case 2: in>>param; Pop(Order[param]);
                break;

            case 3:
                out<<Heap[1].Key<<"\n";
                break;
        }

      /*  for (int i=1; i<=size; i++)
            cout<<Heap[i].Key<<"-"<<Heap[i].Order<<"  ";
        cout<<"\t\t\t\t|  ";
        for (int i=1; i<Order.size(); i++)
            cout<<Order[i]<<" ";
        cout<<endl;*/
    }

    in.close();
    out.close();
    return 0;
}