#include <iostream>
#include <stdio.h>

using namespace std;
const int LOGNMAX = 19, NMAX = 200000;

int myHeap[(1 << LOGNMAX) + 1];
int pos[NMAX + 1], tm[NMAX + 1];

int lastNode;
inline void myswap(int &a, int &b);
inline void swapHeapElem(int a, int b);
inline int parent(int node);
inline int lSon(int node);
inline int rSon(int node);
inline void sift(int node);
inline void percolate(int node);
inline void del(int node);
inline void ins(int val, int t);


int main()
{
    FILE *fin = fopen("heapuri.in", "r");
    FILE *fout = fopen("heapuri.out", "w");
    int n, i, t = 0, act, val;
    fscanf(fin, "%d", &n);
    lastNode = 0;
    for (i = 0; i < n; i++)
    {
        fscanf(fin, "%d", &act);
        if (act == 1)
        {
            fscanf(fin, "%d", &val);
            ins(val, ++t);
        }
        else if (act == 2)
        {
            fscanf(fin, "%d", &val);
            del(pos[val]);
        }
        else
            fprintf(fout, "%d\n", myHeap[1]);
    }
    fclose(fin);
    fclose(fout);



    return 0;
}

inline void myswap(int &a, int &b)
{
    int aux = a;
    a = b;
    b = aux;
}
inline void swapHeapElem(int a, int b)
{
    myswap(myHeap[a], myHeap[b]);
    myswap(tm[a], tm[b]);
    myswap(pos[tm[a]], pos[tm[b]]);
}
inline int parent(int node) {return node >> 1;}
inline int lSon(int node) {return node << 1;}
inline int rSon(int node) {return (node << 1) + 1;}
inline void sift(int node)
{
    while (lSon(node) <= lastNode && (myHeap[node] > myHeap[lSon(node)] || myHeap[node] > myHeap[rSon(node)]))
    {
            if (rSon(node) <= lastNode && myHeap[lSon(node)] > myHeap[rSon(node)])
            {
                swapHeapElem(rSon(node), node);
                node = rSon(node);
            }
            else if (myHeap[lSon(node)] < myHeap[node])
            {
                swapHeapElem(lSon(node), node);
                node = lSon(node);
            }
            else
            node = lSon(node);
    }
}
inline void percolate(int node)
{
    while (parent(node) && myHeap[node] < myHeap[parent(node)])
    {
        swapHeapElem(node, parent(node));
        node = parent(node);
    }
}
inline void del(int node)
{
    swapHeapElem(node, lastNode--);
    if (myHeap[node] < myHeap[parent(node)] && node != 1)
        percolate(node);
    else
        sift(node);

}
inline void ins(int val, int t)
{
    myHeap[++lastNode] = val;
    pos[t] = lastNode;
    tm[lastNode] = t;
    percolate(lastNode);
}