#include<stdio.h>
#define maxDim 200001
#define minim(x,y) (x)<(y) ? (x):(y)

struct H{
int key;
int order;
} heap[maxDim], aux; /*minHeap si variabila auxiliara pentru interschimbare*/

int w[maxDim]; /*w[i] = pozitia in heap a elementului care a fost inserat al i-lea in multime*/
int length, orderN, numOfOperations;

int father(int nod){
	return nod/2;
}

int left_son(int nod){
	return nod*2;
}

int right_son(int nod){
	return nod*2 + 1;
}

/*se "cerne"(coboara) pozitia k pana ii gasim un loc(corect) in heap(ul) de lungime length*/
void sift(int k){

    //printf("facem sift pentru pozitia %d iar length este %d\n", k, length);

	if(k >= length){
		return;
	}

	int son = 0;
	int left = left_son(k);
	//printf("left son: %d\n", left);

	/*daca nu exista fiu stang, nu exista nici fiu drept*/
	if(left <= length){
		int right = right_son(k);
		//printf("right son: %d\n", right);
		if(right <= length && (heap[right].key < heap[left].key)){
			son = right;
		}
		else son = left;

        //printf("son: %d\n", son);

		if(heap[k].key > heap[son].key){
			/*notam modificarea pozitiilor*/
			w[heap[k].order] = son;
			w[heap[son].order] = k;

            //printf("se interschimba %d cu %d\n", heap[k].key, heap[son].key);

			/*interschimbam valorile*/
			aux = heap[k];
			heap[k] = heap[son];
			heap[son] = aux;

			sift(son);
		}
		else return;
	}

}

/*se "infiltreaza"(urca) pozitia k pana ii gasim un loc(corect) in heap(ul) de lungime length*/
void percolate(int k){
	if(k == 1)
		return;

	int parinte = father(k);

	if(heap[k].key < heap[parinte].key){
		/*marcam schimbarea pozitiilor*/
		w[heap[k].order] = parinte;
		w[heap[parinte].order] = k;

		aux = heap[k];
		heap[k] = heap[parinte];
		heap[parinte] = aux;

		percolate(parinte);
	}
	else return;
}

void insert(int value){
	length++;
	heap[length].key = value;

	orderN++;
	heap[length].order = orderN;

	w[orderN] = length;

	percolate(length);
}

void del(int k){
    //printf("am intrat in del. k e %d, iar lui heap[%d] i se atribuie heap[%d]\n", k, k, length);
	heap[k] = heap[length];
	//printf("w[%d] devine %d\n", heap[k].order, k);
	w[heap[k].order] = k;

	length--;

	if ( (k > 1) && (heap[k].key < heap[father(k)].key)) {
	    //printf("se va face percolate pentru ca %d > 1 SI %d < %d\n", k, heap[k].key, heap[father(k)].key);
        percolate(k);
    } else {
        //printf("se va face sift\n");
        sift(k);
    }

}

int main(){

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

	scanf("%d", &numOfOperations);
	//printf("am citit numOfOperations%d\n", numOfOperations);

	int i, operation, value;
	i = 1;
	while(i <= numOfOperations)
		{
			//printf("iteratia: %d ", i);
			scanf("%d", &operation);
			if(operation == 1){
				/*se insereaza value in heap*/
				scanf("%d", &value);
				//printf("operatia inserare a valorii %d.\n", value);
				insert(value);
				//printf("heapul arata cam asa: ");
				//for(int j = 1; j <= length; j++)
					//printf("%d ", heap[j].key);
				//printf("\n");
				//printf("w arata cam asa: ");
				//for(int j = 1; j <= orderN; j++)
					//printf("%d ", w[j]);
				//printf("\n");
			}
			else if(operation == 2){
				/*se sterge elementul intrat al value-lea in multime, in ordine cronologica*/
				scanf("%d", &value);
				//printf("operatia stergere a elem intrat pe poz %d.\n", value);
				del(w[value]);
				//printf("heapul arata cam asa: ");
				//for(int j = 1; j <= length; j++)
					//printf("%d ", heap[j].key);
				//printf("\n");
				//printf("w arata cam asa: ");
				//for(int j = 1; j <= orderN; j++)
					//printf("%d ", w[j]);
				//printf("\n");
			}
			else if(operation == 3){
				/*se afiseaza minimul din heap*/
				//printf("operatia de printare: ");
				printf("%d\n", heap[1]);
			}
			i++;
		}

	return 0;
}