#include <fstream>
#include <bitset>
#include <vector>
#include <algorithm>
using namespace std;

ifstream cin ("heapuri.in");
ofstream cout ("heapuri.out");

const int MAX = 2e5 + 14;

bitset <MAX> fakelyDeleted;

namespace Heap{

    template <typename T>
    void downNode( int node,  const int &numberOfNodes, vector<T> &nodes)
    {
        T minSons;
        if (node * 2 > numberOfNodes)
            return;
        minSons = nodes[node * 2];
        if (node * 2 + 1 <= numberOfNodes)
            minSons = min(minSons, nodes[node * 2 + 1]);
        if (nodes[node] > minSons) {
            if (nodes[node * 2] == minSons) {
                swap(nodes[node], nodes[node * 2]);
                downNode(node * 2, numberOfNodes, nodes);
            }
            else {
                swap(nodes[node], nodes[node * 2 + 1]);
                downNode(node * 2 + 1, numberOfNodes, nodes);
            }
        }
    }

    template <typename T>
    void upNode(int node, const int &numberOfNodes, vector<T> &nodes)
    {
        while(node/2 && nodes[node] < nodes[node/2])
        {
            swap(nodes[node], nodes[node/2]);
            node = node/2;

        }
    }

    template <typename T>
    void push(T value, int &numberOfNodes, vector<T> &nodes)
    {
        numberOfNodes += 1;
        nodes[numberOfNodes] = value;
        upNode(numberOfNodes, numberOfNodes, nodes);

    }

    template <typename T>
    T top(const vector<T> &nodes)
    {
        return nodes[1];
    }

    template <typename T>
    void pop(int & numberOfNodes, vector<T>&nodes)

    {
        swap(nodes[numberOfNodes], nodes[1]);
        numberOfNodes -= 1;
        downNode(1, numberOfNodes, nodes);
    }

};

int main(){
    int Q, numberOfNodes =0;
    cin>>Q;
    vector< pair <int, int> > nodes(Q+10);

    int inserted = 0;
    while (Q --) {
        int tip;
        cin >> tip;
        if (tip == 1) {
            inserted += 1;
            int value;
            cin >> value;
            Heap::push(make_pair(value, inserted), numberOfNodes, nodes);
        }
        else if (tip == 2) {
            int order;
            cin >> order;
            fakelyDeleted[order] = 1;
        }
        else {
            while(fakelyDeleted[Heap::top(nodes).second] == 1) {
                Heap::pop(numberOfNodes, nodes);
            }
            cout << Heap::top(nodes).first << '\n';
        }
    }

    return 0;
}