#include <fstream>
#include <iostream>
#include <unordered_map>
#include <vector>

#define maxn 200010

using namespace std;
class Heap
{
public:
    Heap()
    {
        cnt = 1;
        data.push_back(123);

        // pos2cnt.resize(maxn);
        // cnt2pos.resize(maxn);
    }

    void add(int el)
    {
        // cout << "adding " << el << ". element number: " << cnt << endl;
        data.push_back(el);

        int pos = data.size() - 1;
        cnt2pos[cnt] = pos;
        pos2cnt[pos] = cnt;

        cnt++;
        upHeap(data.size() - 1);
    }

    void remove(int num)
    {
        // cout << "Remove" << endl;
        // print();
        data[cnt2pos[num]] = -1;
        // print();
        upHeap(cnt2pos[num]);
        // print();
        heapSwap(1, data.size() - 1);
        data.pop_back();
        // print();
        downHeap(1);
        // print();
    }

    int minElement()
    {
        return data[1];
    }

private:
    // void print()
    // {
    //     cout << "Heap: ";
    //     for (int i = 0; i < data.size(); i++)
    //     {
    //         cout << data[i] << " ";
    //     }
    //     cout << endl;
    // }
    void print()
    {
        cout << "Heap: ";
        for (int i = 1; i < data.size(); i++)
        {
            cout << data[i] << " ";
        }
        cout << "Cnt2Pos: ";
        for (auto it = cnt2pos.begin(); it != cnt2pos.end(); it++)
        {
            cout << it->first << "->" << it->second << " ";
        }
        cout << "Pos2Cnt: ";
        for (auto it = pos2cnt.begin(); it != pos2cnt.end(); it++)
        {
            cout << it->first << "->" << it->second << " ";
        }
        cout << endl;
    }

    void upHeap(int pos)
    {
        // cout << "UpHeap " << pos << endl;
        if (pos == 1)
        {
            return;
        }
        // for (int parent = pos / 2; parent >= 1 && data[parent] > data[pos]; parent /= 2)
        // {
        //     cout << "parent=" << parent << endl;
        //     heapSwap(pos, parent);
        // }
        int parent = pos / 2;
        while (parent >= 1 && data[parent] > data[pos])
        {
            // cout << parent << " " << pos << endl;
            heapSwap(parent, pos);
            pos = parent;
            parent = parent / 2;
        }
        // print();
    }

    void downHeap(int pos)
    {
        int smallest = pos;
        int left = leftChild(pos);
        int right = rightChild(pos);

        if (left < data.size() && data[smallest] > data[left])
        {
            smallest = left;
        }
        if (right < data.size() && data[smallest] > data[right])
        {
            smallest = right;
        }
        if (smallest != pos)
        {
            heapSwap(pos, smallest);
            downHeap(smallest);
        }
    }

    void heapSwap(int a, int b)
    {
        int cntA = pos2cnt[a];
        int cntB = pos2cnt[b];
        pos2cnt[a] = cntB;
        pos2cnt[b] = cntA;

        cnt2pos[cntA] = b;
        cnt2pos[cntB] = a;

        int aux = data[a];
        data[a] = data[b];
        data[b] = aux;
        // print();
    }

    inline int leftChild(int p)
    {
        return 2 * p;
    }

    inline int rightChild(int p)
    {
        return 2 * p + 1;
    }

    vector<int> data;
    // vector<int> cnt2pos;
    // vector<int> pos2cnt;
    unordered_map<int, int> cnt2pos;
    unordered_map<int, int> pos2cnt;

    int cnt;
};

int main()
{
    ifstream in("heapuri.in");
    ofstream out("heapuri.out");

    int n;
    in >> n;

    Heap heap;
    int query, value;
    for (int i = 0; i < n; i++)
    {
        in >> query;

        if (query == 1)
        {
            in >> value;
            heap.add(value);
        }
        else if (query == 2)
        {
            in >> value;
            heap.remove(value);
        }
        else
        {
            out << heap.minElement() << '\n';
        }
    }
}