#include <fstream>

using namespace std;

ifstream f("heapuri.in");
ofstream g("heapuri.out");

typedef pair < int, int > PII;

const int NMAX = 2e5 + 1;

int Q;

int N, ids;
bool Deactivated[NMAX];

PII H[NMAX];

static inline void Heap_Up (int pos)
{
    if(pos <= 1)
        return;

    int father = (pos >> 1);

    if(H[father].first > H[pos].first)
        swap(H[father], H[pos]), Heap_Up(father);

    return;
}

static inline void Heap_Down (int pos)
{
    if(pos > N)
        return;

    int left_son = (pos << 1);
    int right_son = ((pos << 1) + 1);

    int Min_left = ((left_son <= N) ? H[left_son].first : 1e9 + 1);
    int Min_right = ((right_son <= N) ? H[right_son].first : 1e9 + 1);

    if(H[pos].first < Min_left && H[pos].first < Min_right)
        return;

    if(left_son <= N && right_son <= N)
    {
        if(Min_left < Min_right)
            swap(H[pos], H[left_son]), Heap_Down(left_son);
        else
            swap(H[pos], H[right_son]), Heap_Down(right_son);

        return;
    }

    if(left_son <= N)
        swap(H[pos], H[left_son]), Heap_Down(left_son);

    if(right_son <= N)
        swap(H[pos], H[right_son]), Heap_Down(right_son);

    return;
}

int main()
{
    f.tie(nullptr);

    f >> Q;

    while(Q--)
    {
        short int _type = 0;
        f >> _type;

        if(_type == 1)
        {
            int X = 0;
            f >> X;

            H[++N] = {X, ++ids}, Heap_Up(N);

            continue;
        }

        if(_type == 2)
        {
            int Id = 0;
            f >> Id;

            Deactivated[Id] = 1;

            continue;
        }

        while(N > 0 && Deactivated[H[1].second])
            swap(H[1], H[N]), --N, Heap_Down(1);

        g << H[1].first << '\n';
    }

    return 0;
}