#include <cstdio>
#include <cstring>
#include <cassert>

#include <fstream>
#include <algorithm>
#include <vector>
#include <string>
#include <queue>
#include <map>

using namespace std;

typedef long long LL;
typedef vector<int>::iterator it;

const int oo = 0x3f3f3f3f;
const int MAX_N = 200005;

int N, Values[MAX_N], NHeap, Heap[MAX_N], Position[MAX_N];

inline bool Compare(const int &X, const int &Y) {
    return Values[X] < Values[Y];
}

inline void Swap(const int X, const int Y) {
    swap(Heap[X], Heap[Y]);
    swap(Position[Heap[X]], Position[Heap[Y]]);
}

void Percolate(int X) {
    int Father = X / 2;
    if (Father > 0 && Compare(Heap[X], Heap[Father])) {
        Swap(X, Father);
        Percolate(Father);
    }
}

void Sift(int X) {
    int Son = 2 * X;
    if (Son + 1 <= NHeap && Compare(Heap[Son + 1], Heap[Son]))
        ++Son;
    if (Son <= NHeap && Compare(Heap[Son], Heap[X])) {
        Swap(X, Son);
        Sift(Son);
    }
}

inline void Insert(int X) {
    Heap[++NHeap] = X;
    Position[X] = NHeap;
    Percolate(Position[X]);
}

inline void Erase(int X) {
    X = Position[X];
    Swap(X, NHeap);
    --NHeap;
    Sift(X);
}

int main() {
    assert(freopen("heapuri.in", "r", stdin));
    assert(freopen("heapuri.out", "w", stdout));
    int NQ; assert(scanf("%d", &NQ) == 1);
    for (; NQ > 0; --NQ) {
        int Type; assert(scanf("%d", &Type) == 1);
        if (Type == 1) {
            assert(scanf("%d", &Values[++N]) == 1);
            Insert(N);
        }
        if (Type == 2) {
            int X; assert(scanf("%d", &X) == 1);
            Erase(X);
        }
        if (Type == 3)
            printf("%d\n", Values[Heap[1]]);
    }
    return 0;
}