#define DEBUG 0

#include <fstream>
#if DEBUG == 1
#include <iostream>
#endif
using namespace std;

#define ParentOf(x) (x/2)
#define LChildOf(x) (x*2)
#define RChildOf(x) (x*2 + 1)

struct ItemPos
{
    int key, order;
} Items[100001] ;

class Heap {
    ItemPos *vector;

public:
    int Nodes;
    int Cnt;
    Heap()              { vector = new ItemPos[200001]; Nodes = 0; Cnt = 0; }
    Heap(int capacity)  { vector = new ItemPos[capacity]; Nodes = 0; Cnt = 0; }

    /*Heap(int v[], int len)
    {
        vector = new int[200001];

        Nodes = len;
        for (int i=0; i < Nodes; i++)
            vector[i+1] = v[i];

        for (int i=Nodes/2; i > 0; i--)
            Sift (i);
    }*/

    ~Heap()             { delete[] vector; }

    ItemPos operator[] (int i) { return vector[i]; }

    ItemPos Min()           { return vector[1]; }

    void Sift(int node)
    {
        int child;
        do {
            child = 0;
            int l = LChildOf(node), r = RChildOf(node);

            if (l <= Nodes && r <= Nodes) 
                child = (vector[l].key < vector[r].key) ? l : r ;
            else if (l <= Nodes) child = l;

            if (child && vector[child].key > vector[node].key) child = 0;

            if (child)
            {
                swap (vector[node], vector[child]);
                node = child;
            }
            
        } while (child);
    }
    
    void Percolate (int node)
    {
        ItemPos item = vector[node];

        while ((node > 0) && (item.key < vector[ParentOf(node)].key))
        {
            vector[node] = vector[ParentOf(node)];

            node = ParentOf(node);
        }

        vector[node] = item;
    }

    void Remove (int node)
    {
        vector[node] = vector[Nodes];
        Nodes--;

        if ((node > 1) && (vector[node].key < vector[ParentOf(node)].key))
            Percolate(node);
        else Sift(node);
    }

    void RemoveOrder (int order)
    {
        for (int node=1; node <= Nodes; node++)
            if (vector[node].order == order) {
                Remove(node);
                return;
            }
    }

    void Add (int key)
    {
        vector[++Nodes].key = key;
        vector[Nodes].order = ++Cnt;
        Percolate (Nodes);
    }
};




int main()
{
    Heap h;

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

    int T; in>>T;
    int op, param;

    for (; T > 0; T--)
    {
        in>>op;
        switch (op)
        {
            case 1: in>>param; h.Add(param); break;
            case 2: in>>param; h.RemoveOrder(param); break;
            case 3: out<<h.Min().key<<endl;
#if DEBUG == 1
                cout<<"Question 3 >> "<< h.Min().key<<endl;
#endif
                break;
        }

#if DEBUG == 1
        cout<<"> Items: ";
        for (int i=1; i<=h.Nodes; i++)
            cout<<"("<<h[i].key<<","<<h[i].order<<") ";
        cout<<endl;
#endif
    }

    in.close();
    out.close();
    return 0;
}