#include <fstream>

std::ifstream fin ( "heapuri.in" );
std::ofstream fout ( "heapuri.out" );

const int NMAX = 200000;

class Heap {
    private : 
        int v[1 + NMAX];
        int h[1 + NMAX];
        int poz[1 + NMAX];
        int N, H;
    
    public : 
        Heap();
        ~Heap(){};
        void change ( int x, int y );
        void lower ( int node );
        void upper ( int node );
        void erase ( int node );
        void add ( int node );
        void insert ( int val );
        int getMin ();
        int getPoz ( int x );
};

Heap::Heap() {
    N = H = 0;
}

void Heap::change ( int x, int y ) {
    std::swap ( h[x], h[y] );
    poz[h[x]] = x;
    poz[h[y]] = y;
}

void Heap::lower ( int node ) {
    int left = node * 2;
    int right = node * 2 + 1;
    int tmp = node;
    if ( left <= H && v[h[left]] < v[h[tmp]] )
        tmp = left;
    if ( right <= H && v[h[right]] < v[h[tmp]] )
        tmp = right;
    if ( tmp != node ) {
        change ( node, tmp );
        lower ( tmp );
    }
}

void Heap::upper ( int node ) {
    while ( node > 1 && v[h[node]] < v[h[node / 2]] ) {
        change ( node, node / 2 );
        node = node / 2;
    }
}

void Heap::erase ( int node ) {
    change ( node, H-- );
    upper ( node );
    lower ( node );
}

void Heap::add ( int node ) {
    h[++H] = node;
    poz[node] = H;
    upper ( H );
}

void Heap::insert ( int val ) {
    v[++N] = val;
    add ( N );
}

int Heap::getMin () {
    return v[h[1]];
} 

int Heap::getPoz ( int x ) {
    return poz[x];
}

int main() {
    int N;

    fin >> N;

    Heap heap = Heap();

    for ( int i = 1; i <= N; ++i ) {
        int type, x;
        fin >> type;
        switch ( type ) {
            case 1 : 
                fin >> x;
                heap.insert ( x );
                break;
            case 2 :
                fin >> x;
                heap.erase ( heap.getPoz(x));
                break;
            default :
                fout << heap.getMin() << '\n';
                break;
        }
    }

    fin.close();
    fout.close();

    return 0;
}