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

const int N = 1 + 2e5;

struct Nod{
    int val, P;
    Nod* son[2];

    Nod() : val(0), P(0x7fffffff) {
        son[0] = son[1] = this;
    }
    Nod(int val, int P, Nod* st, Nod* dr) : val(val), P(P) {
    	son[0] = st; son[1] = dr;
    }
} *nil = new Nod();

class Treap {
    Nod *root;

    Nod* &balance(Nod* &x, bool force = false){
    	int b = x -> son[0] -> P > x -> son[1] -> P;
    	if ( !force && x -> P <= x -> son[b] -> P ) return x;
    	Nod* y = x -> son[b];
    	x -> son[b] = y -> son[!b];
    	y -> son[!b] = x;
        x = y;
        return y -> son[!b];
    }
    Nod* &search(Nod* &p, int x) {
        if (p == nil)
            return nil;
        if (p -> val == x)
            return p;
        return search( p -> son[ p -> val < x ], x );
    }
    void insert( Nod* &p, int val, int P = 1 | rand() ) {
//	cerr << "Inserting " << val << " in " << p -> val << '\n';
        if (p == nil) {
            p = new Nod(val, P, nil, nil);
            return;
        }
        if (p -> val == val)
            return;
        insert( p -> son[ p -> val < val ], val, P );
        balance(p);
    }
    void cleanup(Nod* N){
    	if ( N == nil ) return;
    	cleanup( N -> son[0] );
    	cleanup( N -> son[1] );
    	delete N;
    }
public:
    Treap(Nod* root = nil) : root(root) {}
    Nod* find(int x){
        Nod* p = search(root, x);
        return p != nil ? p : NULL;
    }
    void insert(int x){
        insert(root, x);
    }
    void erase(Nod* &p){
//    	cerr << "Deleting " << p -> val << '\n';
        if (p == nil)
            return;
        for (int b = 0; b < 2; b++)
            if ( p -> son[b] == nil ){
            	Nod* aux = p;
            	p = p -> son[!b];
            	delete aux;
            	return;
            }
        erase( balance(p, true) );
        balance(p);
    }

    void erase(int x) {
        erase( search(root, x) );
    }
    void join(Treap& A, Treap& B) {
        root = new Nod(0, 0, A.root, B.root);
        erase(root);
    }
    void split(Treap& A, Treap& B, int prag) {
        insert(root, prag, 0);
        A.root = root -> son[0];
        B.root = root -> son[1];
    }
    int min(){
        Nod* p = root;
        while (p -> son[0] != nil)
            p = p -> son[0];
        return p -> val;
    }
    ~Treap(){
    	cleanup(root);
    }
};

int v[N];

int main(){
    ifstream in("heapuri.in");
    ofstream out("heapuri.out");
    int n, t, x;
    Treap T;

    in >> n;
    while (n--){
        in >> t;
        if ( t != 3 ) in >> x;

        if (t == 1) {
            T.insert(x);
            v[++v[0]] = x;
        } else if ( t == 2 )
        	T.erase( v[x] );
        else
        	out << T.min() << '\n';
    }
    return 0;
}