#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]);
    size--;

    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);

    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;
        }

    }

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