//
// Created by Andrei Covaci on 03.09.2021.
//

#include <fstream>
#include <iostream>
#include <vector>
#include <cmath>
#include <unordered_set>
//#include <climits>

#define INPUT "heapuri.in"
#define OUTPUT "heapuri.out"
//#define INPUT "input.in"
//#define OUTPUT "output.out"

using namespace std;

int heap[200002];
int len = 0;
//bool removed[1000000001];

void insert(int ele) {
    ++len;
    heap[len] = ele;
    int pos = len;

    while(pos > 1) {
        if(heap[pos / 2] > heap[pos]) {
            swap(heap[pos / 2], heap[pos]);
            pos /= 2;
        } else {
            break;
        }
    }
}

int peek() {
    return (len != 0) * heap[1];
}

void remove_top() {
    int pos = 1;
    heap[pos] = heap[len];
    --len;

    while(pos <= (len - 1) / 2) {
        if(heap[pos * 2] < heap[pos * 2 + 1] && heap[pos * 2] < heap[pos]) {
            swap(heap[pos], heap[pos * 2]);
            pos *= 2;
        } else if (heap[pos * 2] >= heap[pos * 2 + 1] && heap[pos * 2 + 1] < heap[pos]) {
            swap(heap[pos], heap[pos * 2 + 1]);
            pos = pos * 2 + 1;
        } else {
            break;
        }
    }
    if(len % 2 != 0 && heap[len - 1] < heap[len] && heap[len - 1] < heap[len / 2])
        swap(heap[len - 1], heap[len / 2]);
    else if (heap[len] < heap[len / 2])
        swap(heap[len], heap[len / 2]);
}

//void remove(int ele) {
//    int pos = 1;
//    for(; pos <= len; ++pos) if (heap[pos] == ele) break;
//
//    if (pos == len + 1) return;
//    if (pos == len) { len--; return; }
//    if (pos == 1) { remove_top(); return; }
//
//    heap[pos] = heap[len];
//    --len;
//
//    if (heap[pos] < heap[pos / 2]) {
//        while(pos > 1) {
//            if(heap[pos / 2] > heap[pos]) {
//                swap(heap[pos / 2], heap[pos]);
//                pos /= 2;
//            } else {
//                break;
//            }
//        }
//    } else if (heap[pos] > heap[pos * 2] || heap[pos] > heap[pos * 2 + 1]) {
//        while(pos <= (len - 1) / 2) {
//            if(heap[pos * 2] < heap[pos * 2 + 1] && heap[pos * 2] < heap[pos]) {
//                swap(heap[pos], heap[pos * 2]);
//                pos *= 2;
//            } else if (heap[pos * 2] >= heap[pos * 2 + 1] && heap[pos * 2 + 1] < heap[pos]) {
//                swap(heap[pos], heap[pos * 2 + 1]);
//                pos = pos * 2 + 1;
//            } else {
//                break;
//            }
//        }
//        if(len % 2 != 0 && heap[len - 1] < heap[len] && heap[len - 1] < heap[len / 2])
//            swap(heap[len - 1], heap[len / 2]);
//        else if (heap[len] < heap[len / 2])
//            swap(heap[len], heap[len / 2]);
//    }
//}

int main() {
    ifstream in(INPUT);
    ofstream out(OUTPUT);

    vector<int> res, hist;

    int n, task, val;
    in >> n;

    unordered_set<int> removed;

    for(; n; --n) {
        in >> task;
        if(task == 1) {
            in >> val;
            hist.emplace_back(val);
            insert(val);
        } else if(task == 2) {
            in >> val;
            removed.insert(hist[--val]);

        } else {
            while(removed.count(peek())) {
                remove_top();
            }
            out << peek() << '\n';
        }
    }

    in.close();
    out.close();

    return 0;
}