#include <iostream>
#include <stdio.h>
#include <map>

using namespace std;
int minH[2000000];
//x, pos in heap
int Pos[2000000];
int V[2000000];
int min_heap_size;
int N;




int parent(int i){
    return i/2;
}


int left(int i){
    return 2*i;
}


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


void min_heapify(int i){
    int left_i = left(i);
    int right_i = right(i);
    int min_i = i;

    if(left_i <= min_heap_size && V[minH[left_i]] < V[minH[i]])
        min_i = left_i;
    else
        min_i = i;

    if(right_i <= min_heap_size && V[minH[right_i]] < V[minH[min_i]])
        min_i = right_i;

    if(min_i != i){
        swap(minH[i], minH[min_i]);

       Pos[minH[i]] = i;
       Pos[minH[min_i]] = min_i;
        min_heapify(min_i);
    }
}




void inserare_min_heap(int i){
    min_heap_size++;
    minH[min_heap_size] = i;
    Pos[i] = min_heap_size;

    int k = min_heap_size;
    while(V[minH[k]] < V[minH[parent(k)]] && k>1){
        swap(minH[k], minH[parent(k)]);

        Pos[minH[k]] = k;
        Pos[minH[k/2]] = k/2;

        k = parent(k);
    }
}



int minim_heap()
{
    return V[minH[1]];
}

void sterge_elem(int pos){

 //   Pos[minH[min_heap_size]] = Pos[pos];

    swap(minH[Pos[pos]], minH[min_heap_size]);

     Pos[minH[Pos[pos]]] = Pos[minH[min_heap_size]];

    if(min_heap_size >0){
        min_heap_size--;

    }
     min_heapify(Pos[pos]);

}



int main()
{
    freopen("heapuri.in", "r",stdin);
    freopen("heapuri.out", "w", stdout);

    int op, x;

    int N;

    scanf("%d", &N);
    int k = 1;

    for(int i=1; i<=N; i++){
        scanf("%d", &op);
        if(op == 3){
            printf("%d\n", minim_heap());
        }
        else{
            scanf("%d", &x);
            if(op == 1){
                V[k] = x;

                inserare_min_heap(k);
                k++;
            }
                else
                sterge_elem(x);
        }
    }





    return 0;
}