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

using namespace std;
int minH[1000000];
//x, pos in heap
map<int, int> Pos;
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 && minH[left_i] < minH[i])
        min_i = left_i;
    else
        min_i = i;

    if(right_i <= min_heap_size && minH[right_i] < 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 build_min_heap(){
    for(int i=min_heap_size/2; i>=1; i--)
    {
        min_heapify(i);
    }
}


void decapitare_min_heap(){
    swap(minH[1], minH[min_heap_size]);
    Pos[minH[min_heap_size]] = 1;
    if(min_heap_size >0){
        min_heap_size--;
        min_heapify(1);
    }
}

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(minH[k] < 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 minH[1];
}

void sterge_elem(int pos){

    Pos[minH[min_heap_size]] = Pos[V[pos]];
    swap(minH[Pos[V[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;
                k++;
                inserare_min_heap(x);
            }
                else
                sterge_elem(x);
        }
    }


    return 0;
}