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

int heap[200000];
int insert_order[1000000];

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

int right_child(int i) { return 2 * i + 2; }

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

void heap_insert(int heap[], int* size, int key) {

	int i = *size;
	int p = parent(i);

	(*size)++;
	
	while (p > 0) {

		if (heap[p] > key) {

			heap[i] = heap[p];
			
			i = p;
			p = parent(i);
		}
	}

	if (p == 0 && heap[0] > key) {
		
		heap[i] = heap[0];

		i = p;
	}

	heap[i] = key;
}

int get_min(int heap[], int heap_size) {

	if (heap_size) {

		return heap[0];
	}

	return -1;
}

void min_heapify(int heap[], int n, int i) {

	int mini = i;
	int left = left_child(i);
	int right = right_child(i);

	if (left < n && heap[left] < heap[i]) {
		
		mini = left;
	}
	else {

		mini = i;
	}

	if (right < n && heap[right] < heap[mini]) {

		mini = right;
	}

	if (mini != i) {

		int aux = heap[i];
		heap[i] = heap[mini];
		heap[mini] = aux;

		min_heapify(heap, n, mini);
	}
}

void delete_index(int heap[], int* size, int key) {

	int index;

	for (int i = 0; i < *size; i++) {

		if (heap[i] == key) {

			index = i;
			break;
		}
	}

	heap[index] = heap[*size - 1];
	(*size)--;

	min_heapify(heap, *size, index);
}

void build_heap(int heap[], int n) {

	int mid = (n - 1) / 2;

	for (int i = mid; i >= 0; i--) {

		min_heapify(heap, n, i);
	}
}

int main() {

	int n;
	int heap_size = 0;
	int order_size = 0;
	int cod, x;

	FILE* ip = fopen("heapuri.in", "r");
	if (!ip) {

		perror("could not open input file");
		exit(1);
	}

	FILE* op = fopen("heapuri.out", "w");
	if (!op) {

		perror("could not open output file");
		exit(1);
	}

	fscanf(ip, "%d", &n);

	for (int i = 0; i < n; i++) {

		fscanf(ip, "%d", &cod);

		if (cod == 1) {

			fscanf(ip, "%d", &x);

			heap_insert(heap, &heap_size, x);

			insert_order[order_size] = x;
			order_size++;
		}
		else if (cod == 2) {

			fscanf(ip, "%d", &x);

			delete_index(heap, &heap_size, insert_order[x - 1]);
		}
		else if (cod == 3) {

			fprintf(op, "%d\n", get_min(heap, heap_size));
		}
	}

	fclose(ip);
	fclose(op);

	return 0;
}