#include <iostream>
#include <fstream>
#define NMAX 200000

using namespace std;

ifstream fin("heapuri.in");
ofstream fout("heapuri.out");

int N, x, op;
int dim, contor;
int heap[2*NMAX], pozInHeap[NMAX], value[NMAX];

bool cmp(int i, int j){
    return value[heap[i]] < value[heap[j]];
}

inline int parent(int i){
    return (i - 1) / 2;
}

inline int leftSon(int i){
    return 2 * i + 1;
}

inline int rightSon(int i){
    return 2 * i + 2;
}

int peek(){
    return heap[0];
}

void interschimba(int i, int j){
    int aux;
    aux = heap[i], heap[i] = heap[j], heap[j] = aux;
    pozInHeap[heap[i]] = i;
    pozInHeap[heap[j]] = j;
}

void heapifyUp(int i){
    while (i && !cmp(parent(i), i)){
        interschimba(i, parent(i));
        heapifyUp(parent(i));
    }
}

void push(int val){
    heap[dim] = contor;
    pozInHeap[contor] = dim;
    value[contor] = val;
    dim++, contor++;
    heapifyUp(dim - 1);
}

void heapifyDown(int i){
    int left = leftSon(i), right = rightSon(i), maxIndex = i;

    if (left < dim && cmp(left, maxIndex)) maxIndex = left;
    if (right < dim && cmp(right, maxIndex)) maxIndex = right;

    if (maxIndex != i){
        interschimba(i, maxIndex);
        heapifyDown(maxIndex);
    }
}

void removeIndex(int i){
    heap[i] = heap[dim - 1];
    --dim;

    if (i && !cmp(parent(i), i)) heapifyUp(i);
    else heapifyDown(i);
}

int main()
{
    fin >> N;
    for (int i = 0; i < N; ++i) {
        fin >> op;
        if (op == 1){
            fin >> x;
            push(x);
        }
        else if (op == 2){
            fin >> x;
            removeIndex(pozInHeap[x - 1]);
        }
        else
            fout << value[peek()] << '\n';
    }

    fin.close();
    fout.close();
    return 0;
}