#include <fstream>
#include <vector>

template <class elem_t, class Compare = std::less<int> >
class heap
{
    std::vector<int> pos;
    std::vector<elem_t> x;
    Compare comp;

    bool leaf (unsigned p)
    {
        if (p <= (x.size()-1)/2) return false;
        return true;
    }

    void upheap (unsigned currentpos)
    {
        while (comp (x[currentpos].key(), x[currentpos/2].key()) && currentpos != 1) {
            std::swap (x[currentpos], x[currentpos/2]);
            pos[x[currentpos].num()] = currentpos;
            pos[x[currentpos/2].num()] = currentpos/2;
            currentpos /= 2;
        }
    }

    void downheap (unsigned currentpos)
    {
        unsigned minpos;

        while (not leaf (currentpos)) {
            minpos = currentpos;
            if (not comp (x[minpos].key(), x[currentpos*2].key())) {
                minpos = currentpos*2;
            }
            if (currentpos*2+1 <= x.size()-1) {
                if (not comp (x[minpos].key(), x[currentpos*2+1].key())) {
                    minpos = currentpos*2+1;
                }
            }
            if (minpos == currentpos) break;
            std::swap (x[currentpos], x[minpos]);
            pos[x[currentpos].num()] = currentpos;
            pos[x[minpos].num()] = minpos;
            currentpos = minpos;
        }
    }

public:
    heap (unsigned n): pos(n, -1), x(1) {}
    ~heap () {pos.clear(); x.clear();}

    void push (elem_t elem)
    {
        x.push_back (elem);
        unsigned currentpos = x.size()-1;
        pos[elem.num()] = currentpos;
        upheap (currentpos);
    }

    elem_t top ()
    {
        return x[1];
    }

    unsigned size ()
    {
        return x.size()-1;
    }

    bool exists (unsigned p)
    {
        if (pos[p] == -1) return false;
        return true;
    }

    void pop ()
    {
        pos[x[1].num()] = -1;
        x[1] = x.back();
        pos[x[1].num()] = 1;
        x.pop_back();
        downheap (1);
    }

    void change_key (int node, int val)
    {
        x[pos[node]].set_key(val);
        upheap (pos[node]);
    }
};

class tipus
{
    int sorszam, kulcs;

public:
    tipus () {}
    tipus (int s, int k): sorszam(s), kulcs(k) {}
    int key() {return kulcs;}
    int num() {return sorszam;}
    void set_key (int k) {kulcs = k;}
};

int main()
{
    std::ifstream be("heapuri.in");
    std::ofstream ki("heapuri.out");

    int n, i, op1, op2, aktsorszam(0);
    be >> n;

    heap<tipus> kupac(n);

    for (i=1; i<=n; i++) {
        be >> op1;

        if (op1 == 1) {
            be >> op2;
            aktsorszam++;
            kupac.push (tipus(aktsorszam, op2));
        }
        else if (op1 == 2) {
            be >> op2;
            kupac.change_key(op2, -999999999);
            kupac.pop();
        }
        else if (op1 == 3) {
            ki << kupac.top().key() << "\n";
        }
    }
}