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

using namespace std;
int minH[1000000];
//x, pos in heap
int Pos[1000000];
int V[1000000];
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]);
       swap(Pos[minH[i]], Pos[minH[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)]);
        swap(Pos[minH[k]], Pos[minH[parent(k)]]);
        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]);


    if(min_heap_size >0){
        min_heap_size--;
        min_heapify(1);
    }

}

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;
}