#include <iostream>
#include <fstream>
#define NMAX 200005
using namespace std;

ifstream fin("heapuri.in");
ofstream fout("heapuri.out");
struct element
{
    int val;
    int ordine;
};

element minHeap[NMAX];
int heapSize = 0;
int nrInserare = 1;

int fiuStang(int pozitie){return pozitie * 2;}

int fiuDrept(int pozitie){return pozitie * 2 + 1;}

int tata(int pozitie){return pozitie/2;}

void down(element minHeap[], int k)
{  int fiu;
    do
    {   fiu = 0;
        if(fiuStang(k) <= heapSize)
         {
              fiu = fiuStang(k);
                  if(fiuDrept(k) <= heapSize && minHeap[fiuDrept(k)].val < minHeap[fiuStang(k)].val)
                      fiu = fiuDrept(k);
         }
         if(minHeap[fiu].val >= minHeap[k].val)
            fiu = 0;

         if(fiu)
         {
              swap(minHeap[fiu].val, minHeap[k].val);
              swap(minHeap[fiu].ordine, minHeap[k].ordine);
              k = fiu;
         }


    }while(fiu != 0);
}

void up(element minHeap[], int k)
{
    while((k > 1) && minHeap[k].val < minHeap[tata(k)].val)
    {
        swap(minHeap[k].val, minHeap[tata(k)].val);
        swap(minHeap[k].ordine, minHeap[tata(k)].ordine);
        k = tata(k);
    }
}
void inserare(int x)
{
    heapSize++;
    minHeap[heapSize].val = x;
    minHeap[heapSize].ordine = nrInserare++;
    down(minHeap, heapSize);
}

void stergere(int x)
{   int i;
    for(i = 1; i <= heapSize; i++)
        if (minHeap[i].ordine == x)
            break;

    minHeap[i] = minHeap[heapSize];
    heapSize--;
    if((i > 1) && (minHeap[i].val < minHeap[tata(i)].val))
        up(minHeap, i);
    else
        down(minHeap, i);

}

int getMin(element minHeap[]){return minHeap[1].val;}

int main()
{
    int n, op, x;
    fin >> n;
    for(int i = 0; i < n; i++)
    {
        fin >> op;
        switch(op)
        {
        case 1:
            fin >> x;
            inserare(x);
            break;
        case 2:
            fin >>x;
            stergere(x); // pozitia nu valoarea
            break;
        case 3:
            fout << getMin(minHeap) << "\n";
            break;

        }
    }

    return 0;
}