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

typedef struct
{
    int *data;
    int *pozitie;
    int *ordine;
    int dimensiune;
    int capacitate;
} MinHeap;

MinHeap *newHeap(int capacitate)
{
    MinHeap *heap = (MinHeap *)malloc(sizeof(MinHeap));
    heap->data = (int *)malloc(capacitate * sizeof(int));
    heap->pozitie = (int *)malloc(capacitate * sizeof(int));
    heap->ordine = (int *)malloc(capacitate * sizeof(int));
    heap->dimensiune = 0;
    heap->capacitate = capacitate;
    return heap;
}

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

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

    heap->pozitie[heap->ordine[i]] = i;
    heap->pozitie[heap->ordine[j]] = j;
}

void heapifyUp(MinHeap *heap, int index)
{
    int parinte = (index - 1) / 2;
    if (index > 0 && heap->data[index] < heap->data[parinte])
    {
        swap(heap, index, parinte);
        heapifyUp(heap, parinte);
    }
}

void heapifyDown(MinHeap *heap, int index)
{
    int min = index;
    int stanga = 2 * index + 1;
    int dreapta = 2 * index + 2;

    if (stanga < heap->dimensiune && heap->data[stanga] < heap->data[min])
    {
        min = stanga;
    }
    if (dreapta < heap->dimensiune && heap->data[dreapta] < heap->data[min])
    {
        min = dreapta;
    }
    if (min != index)
    {
        swap(heap, index, min);
        heapifyDown(heap, min);
    }
}

void insereazaHeap(MinHeap *heap, int valoare, int poz)
{
    if (heap->dimensiune == heap->capacitate)
    {
        heap->capacitate *= 2;
        heap->data = (int *)realloc(heap->data, heap->capacitate * sizeof(int));
        heap->pozitie = (int *)realloc(heap->pozitie, heap->capacitate * sizeof(int));
        heap->ordine = (int *)realloc(heap->ordine, heap->capacitate * sizeof(int));
    }
    heap->data[heap->dimensiune] = valoare;
    heap->pozitie[poz] = heap->dimensiune;
    heap->ordine[heap->dimensiune] = poz;
    heapifyUp(heap, heap->dimensiune);
    heap->dimensiune++;
}

void stergere(MinHeap *heap, int p)
{
    int index = heap->pozitie[p];
    swap(heap, index, heap->dimensiune - 1);
    heap->dimensiune--;
    heapifyDown(heap, index);
    heapifyUp(heap, index);
}

int getMin(MinHeap *heap)
{
    if (heap->dimensiune == 0)
        return -1;
    return heap->data[0];
}

int main()
{
    FILE *fin, *fout;
    fin = fopen("heapuri.in", "r");
    fout = fopen("heapuri.out", "w");
    int n;
    fscanf(fin, "%d", &n);

    MinHeap *heap = newHeap(n);
    int pozitie = 0;

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

        if (cod == 1)
        {
            fscanf(fin, "%d", &x);
            insereazaHeap(heap, x, pozitie);
            pozitie++;
        }
        else if (cod == 2)
        {
            fscanf(fin, "%d", &x);
            stergere(heap, x - 1);
        }
        else if (cod == 3)
        {
            int min = getMin(heap);
            if (min != -1)
                fprintf(fout, "%d\n", min);
        }
    }

    free(heap->data);
    free(heap->pozitie);
    free(heap);

    fclose(fin);
    fclose(fout);

    return 0;
}