#include <iostream>
#include <fstream>
#include <vector>
#include <utility>

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

int n;
//pastrez perechi (element, pozitie in heap)
vector < pair<int,int> > v;
//pastrez perechi (element, pozitie in vectorul initial)
vector < pair<int,int> > min_heap;

int sz_min_heap,sz_v;

int Parinte(int i)
{
    return (i-1)/2;
}

int IndexStanga(int i)
{
    return 2*i+1;
}

int IndexDreapta(int i)
{
    return 2*i+2;
}

void coboara(int i)
{
    int st,dr,pozmin;
    st=IndexStanga(i);
    dr=IndexDreapta(i);

    pozmin=i;
    //verific daca e mai mic decat fii sai
    if(st<sz_min_heap && min_heap[st].first<min_heap[pozmin].first)
        pozmin=st;
    if(dr<sz_min_heap && min_heap[dr].first<min_heap[pozmin].first)
        pozmin=dr;

    if(pozmin!=i) //v[i] nu e mai mic decat ambii=> trebuie sa-i dau swap cu fiul cel mai mic
    {
        swap(min_heap[i].first,min_heap[pozmin].first);
        swap(min_heap[i].second,min_heap[pozmin].second);
        //trebuie sa actualizez pozitiile elementelor din heap
        swap(v[min_heap[pozmin].second].second,v[min_heap[i].second].second);

        coboara(pozmin);
    }

}
void HeapPop(int poz)
{
    //il pun pe ultima pozitie, il elimin dupa care refac structura de min_heap

    swap(min_heap[sz_min_heap-1].first,min_heap[poz].first);
    swap(min_heap[sz_min_heap-1].second,min_heap[poz].second);
    swap(v[min_heap[poz].second].second,v[min_heap[sz_min_heap-1].second].second);

    min_heap.pop_back();
    sz_min_heap--;

    coboara(poz);

}

void urca(int poz)
{
    int pozparinte=Parinte(poz);
    //verific sa fie mai mare decat parintele
    if(poz>0 && min_heap[pozparinte].first>min_heap[poz].first) //trebuie sa fac swap
    {
        swap(min_heap[pozparinte].first,min_heap[poz].first);
        swap(min_heap[pozparinte].second,min_heap[poz].second);
        //trebuie sa actualizez pozitiile elementelor din heap
        //interschimb pozitiile din vector care retineau unde se afla elementele in heap

        swap(v[min_heap[poz].second].second,v[min_heap[pozparinte].second].second);

        urca(pozparinte);
    }


}

int main()
{
    int x,task;
    fin>>n;
    for(int i=0; i<n; i++)
    {
        fin>>task;
        if(task==1) // se insereaza elementul x in multime
        {
            fin>>x;

            sz_min_heap++;
            v.push_back(make_pair(x,sz_min_heap-1));
            sz_v++;
            min_heap.push_back(make_pair(x,sz_v-1)); //adaug la final si apelez urca

            urca(sz_min_heap-1);

        }
        else if(task==2) // se sterge elementul intrat al x-lea in multime
        {
            fin>>x;
            HeapPop(v[x-1].second); //x-1 pentru ca am indexare de la 0
        }
        else //task 3= se afiseaza elementul minim din multime
        {
            fout<<min_heap.front().first<<"\n";

        }
    }


    return 0;
}