#include <stdio.h>

#define MAX_HEAP_SIZE	200000

struct Node
{
	Node()
	{
		order = 0;
		value = 0;
	}

	Node(int v, int o)
	{
		value = v;
		order = o;
	}

	int value;
	int order;
};

typedef Node Heap[MAX_HEAP_SIZE];

Heap h = {Node()};
int size = 0, order = 0;

inline int get_parent(const int i)
{
	return i / 2;
}

inline int get_left(const int i)
{
	return 2 * i;
}

inline int get_right(const int i)
{
	return 2 * i + 1;
}

int min()
{
	return h[1].value;
}

void heapify(int n, int k)
{
	int smalest = k;
	int l = get_left(k);
	int r = get_right(k);

	if (l <= n && h[l].value < h[k].value) 
		smalest = l;

	if (r <= n && h[r].value < h[smalest].value)
		smalest = r;

	if (smalest != k) {
		int aux = h[k].value;
		h[k].value = h[smalest].value;
		h[smalest].value = aux;
		aux = h[k].order;
		h[k].order = h[smalest].order;
		h[smalest].order = aux;
		heapify(n, smalest);
	}
}

void insert_value(int x)
{
	int son, parent;
	size++;
	order++;
	h[size] = Node(x, order);
	son = size;
	parent = son / 2;

	while (h[parent].value > h[son].value)
	{
		int aux = h[parent].value;
		h[parent].value = h[son].value;
		h[son].value = aux;
		aux = h[parent].order;
		h[parent].order = h[son].order;
		h[son].order = aux;

		son = parent;
		parent = son / 2;
	}
}

int delete_chr(int n, int x)
{
	if (h[n].order == x)
	{
		h[n].order = h[size].order;
		h[n].value = h[size].value;
		size--;
		heapify(size, n);

		return 1;
	}

	if (get_left(n) <= size)
	{
		if (delete_chr(get_left(n), x))
			return 1;
	}

	if (get_right(n) <= size)
	{
		if (delete_chr(get_right(n), x))
			return 1;
	}

	return 0;
}

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

	scanf("%d\n", &ops_no);
	
	for (int i = 0; i < ops_no; i++)
	{
		int code, x;
		scanf("%d", &code);
		switch (code)
		{
			case 1:
				scanf("%d\n", &x);
				insert_value(x);
				break;
			case 2:
				scanf("%d\n", &x);
				delete_chr(1, x);
				break;
			case 3:
				printf("%d\n", min());
				break;
		}
	}

	return 0;
}