#include <fstream>
#include <cstdlib>
using namespace std;

const int inf = 0x3f3f3f3f, N = 200005;

struct Nod
{
    int val, P;
    Nod *st, *dr;

    Nod()
    {
        val = P = 0;
        st = dr = this;
    }

    Nod(int _val, int _P, Nod* _st, Nod* _dr)
    {
        val = _val;
        P = _P;
        st = _st;
        dr = _dr;
    }
} *nil = new Nod();

struct Treap
{
    Nod *root;

    Treap()
    {
        root = nil;
    }

    Nod* &search(Nod* &p, int x)
    {
        if (p == nil)
            return nil;
        if (p -> val == x)
            return p;
        return search(x < p -> val ? p -> st : p -> dr, x);
    }

    Nod* &search(int x)
    {
        return search(root, x);
    }

    Nod* find(int x)
    {
        Nod* p = search(root, x);
        return p != nil ? p : NULL;
    }

    void rotate_left(Nod* &x)
    {
        Nod* y = x -> st;
        x -> st = y -> dr;
        y -> dr = x;
        x = y;
    }

    void rotate_right(Nod* &x)
    {
        Nod* y = x -> dr;
        x -> dr = y -> st;
        y -> st = x;
        x = y;
    }

    void balance(Nod* &x)
    {
        if (x -> st -> P > x -> P)
            rotate_left(x);
        if (x -> dr -> P > x -> P)
            rotate_right(x);
    }

    void insert(Nod* &p, Nod* nod)
    {
        if (p == nil)
        {
            p = nod;
            return;
        }

        if (p -> val == nod -> val)
            return;

        insert(nod -> val <= p -> val ? p -> st : p -> dr, nod);

        balance(p);
    }

    void insert(int x)
    {
        insert(root, new Nod(x, rand() + 1, nil, nil));
    }

    void erase(Nod* &p)
    {
        if (p == nil)
            return;

        if (p -> st == nil || p -> dr == nil)
        {
            Nod* aux = p;
            p = (p -> st == nil ? p -> dr : p -> st);
            delete aux;
            return;
        }

        if (p -> st -> P > p -> dr -> P)
        {
            rotate_left(p);
            erase(p -> dr);
        }
        else
        {
            rotate_right(p);
            erase(p -> dr);
        }

        balance(p);
    }

    void erase(int x)
    {
        erase(search(root, x));
    }

    void join(Treap& A, Treap& B)
    {
        root = new Nod(0, 1, A.root, B.root);
        erase(root);
    }

    void split(Treap& A, Treap& B, int prag)
    {
        insert(root, new Nod(prag, inf, nil, nil));
        A.root = root -> st;
        B.root = root -> dr;
    }

    int minim()
    {
        Nod* p = root;

        while (p -> st != nil)
            p = p -> st;

        return p -> val;
    }
};

int v[N];

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

int main()
{
    int n, x;
    Treap T;

    in >> n;

    while (n--)
    {
        in >> x;

        if (x == 1)
        {
            in >> x;
            T.insert(x);
            v[++v[0]] = x;
            continue;
        }

        if (x == 2)
        {
            in >> x;
            T.erase(v[x]);
            continue;
        }

        out << T.minim() << "\n";
    }
    return 0;
}