#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int *array;//valorile elementelor din heap
    int *poz;//pozitiile elementelor din heap
    int *order;//ordinea inserarii elementelor
    int size;//dimensiune curenta
    int dim;//capacitate totala
}H;

H *creare(int capacitate)
{
    H *heap=(H*)malloc(sizeof(H));
    if(!heap)
        return NULL;
    heap->array=(int *)malloc(capacitate*sizeof(int));
    heap->poz=(int *)malloc(capacitate*sizeof(int));
    heap->order=(int *)malloc(capacitate*sizeof(int));
    heap->size=0;
    heap->dim=capacitate;
    return heap;
}

void swap(H *heap,int i,int j)
{
    int aux=heap->array[i];
    heap->array[i]=heap->array[j];
    heap->array[j]=aux;

    aux=heap->order[i];
    heap->order[i]=heap->order[j];
    heap->order[j]=aux;

    heap->poz[heap->order[i]]=i;
    heap->poz[heap->order[j]]=j;
}

void minHeapify(H *heap,int i)
{
    /*comparam in lant elementul cu parintele,si interschimbam,pentru a pastra
    minimul la radacina
    */
    while(i>0 && heap->array[i]<heap->array[(i-1)/2])
    {
        swap(heap,i,(i-1)/2);
        i=(i-1)/2;
    }
}

void actualizare(H *heap,int i)
{
    int fiu_stang,fiu_drept,minim;
    while(1)
    {
        fiu_stang=2*i+1;
        fiu_drept=2*i+2;
        minim=i;//consideram ca minimul e radacina

        if(fiu_stang<heap->size && heap->array[fiu_stang]<heap->array[minim])
            minim=fiu_stang;
        if(fiu_drept<heap->size && heap->array[fiu_drept]<heap->array[minim])
            minim=fiu_drept;
        if(minim!=i)
        {
            swap(heap,i,minim);
            i=minim;
        }
        else
            break;
    }
}

void inserare(H *heap,int val,int p)
{
    if(heap->size==heap->dim)
    {
        heap->dim+=200;
        heap->array=(int*)realloc(heap->array, heap->dim*sizeof(int));
        heap->poz = (int*)realloc(heap->poz, heap->dim * sizeof(int));
        heap->order = (int*)realloc(heap->order, heap->dim * sizeof(int));
    }
    heap->array[heap->size]=val;//il adaugam la final
    heap->poz[p]=heap->size;
    heap->order[heap->size]=p;
    heap->size++;
    minHeapify(heap,heap->size-1);

}

/*int getMin(H *heap)
{
    if(heap->size==0)
        return -1;
    int min=heap->array[0];
    swap(heap,0,heap->size-1);
    heap->size--;
    actualizare(heap,0);
    return min;
}*/

void stergere(H *heap,int p)
{
    int i=heap->poz[p];
    swap(heap,i,heap->size-1);//il inlocuim cu ultimul,apoi decrementam size
    heap->size--;
    actualizare(heap,i);
    minHeapify(heap,i);
}

int returnMin(H *heap)
{
    if(heap->size==0)
        return -1;
    return heap->array[0];
}

int main(int argc,char **argv)
{
    FILE *f1=fopen("heapuri.in","r"),*f2=fopen("heapuri.out","w");
    if(!f1|| !f2)
    {
        perror(NULL);
        exit(-1);
    }

    int n;
    fscanf(f1,"%d",&n);

    H *heap=creare(n);
    int poz=0;

    for(int i=0;i<n;i++)
    {
        int cod,x;
        fscanf(f1,"%d",&cod);

        if (cod == 1)
        {
            fscanf(f1, "%d", &x);
            inserare(heap,x,poz);
            poz++;
        }
        else if (cod == 2)
        {
            fscanf(f1, "%d", &x);
            stergere(heap,x- 1);//x-1 pentru ca in vectorul order am indexat de la 0
        }
        else if (cod == 3)
        {
            int min =returnMin(heap);
            if(min!=-1)
                fprintf(f2, "%d\n", min);
        }
    }
    free(heap->array);
    free(heap->poz);
    free(heap->order);
    free(heap);

    if(fclose(f1)!=0 || fclose(f2)!=0)
    {
        perror(NULL);
        exit(-1);
    }
    return 0;
}