#include <iostream>
#include <fstream>

#define MAX_ELEMS 200001u

using namespace std;

struct Heappy
{
    unsigned int val;
    size_t nod;
}Heap[MAX_ELEMS], aux;

size_t Log[MAX_ELEMS], aaux;

size_t nr_nod_log = 0, nr_nod_heap = 0;

inline size_t parent(size_t y)
{
    return (y/2);
}

inline size_t left(size_t y)
{
    return (y*2);
}

inline size_t right(size_t y)
{
    return (y*2 + 1);
}

void exchange(size_t nod1, size_t nod2)
{
    Log[Heap[nod1].nod] = nod2;
    Log[Heap[nod2].nod] = nod1;

    aux = Heap[nod1];
    Heap[nod1] = Heap[nod2];
    Heap[nod2] = aux;
}

void heapifyUP(size_t node)
{
    while(parent(node) && Heap[node].val < Heap[parent(node)].val)
    {
        exchange(node, parent(node));

        node = parent(node);
    }
}

void heapifyDOWN(size_t node)
{
    size_t minim;
    do
    {
        minim = 0;
        if(left(node) <= nr_nod_heap)
        {
            minim = left(node);
            if(right(node) <= nr_nod_heap && Heap[right(node)].val < Heap[left(node)].val)
            {
                minim = right(node);
            }
            if(Heap[minim].val >= Heap[node].val)
            {
                minim = 0;
            }
        }
        if(minim)
        {
            exchange(node, minim);
            node = minim;
        }
    }while(minim);
}

void inserare(unsigned int elem)
{
    nr_nod_log++;
    nr_nod_heap++;
    Heap[nr_nod_heap].val = elem;
    Heap[nr_nod_heap].nod = nr_nod_log;
    Log[nr_nod_log] = nr_nod_heap;
//cout << elem << "," << nr_nod_log << endl;
    heapifyUP(nr_nod_heap);
}

void eliminare(unsigned int poz)
{
    Log[Heap[nr_nod_heap].nod] = poz;
    Heap[poz] = Heap[nr_nod_heap];
    nr_nod_heap--;

    heapifyUP(poz);
    heapifyDOWN(poz);
}

unsigned int minim()
{
    return Heap[1].val;
}

int main()
{

    unsigned int N, opt, elem;
    ifstream fin("heapuri.in");
    ofstream fout("heapuri.out");
    fin >> N;

    for(size_t k = 0; k < N; k++)
    {
        fin >> opt;
        if(opt == 1)
        {
            fin >> elem;
            inserare(elem);
            continue;
        }
        if(opt == 2)
        {
            fin >> elem;
            eliminare(Log[elem]);
            continue;
        }
        if(opt == 3)
        {
            fout << minim() << "\n";
        }
    }
    fin.close();
    fout.close();

    return 0;
}