#include <iostream>
#include <fstream>
#include <unordered_map>

using namespace std;

ifstream fin("heapuri.in");
ofstream fout("heapuri.out");

const int N = 2e5 + 5;

int indexElementToNod[N];		// [indexElement] = nod
int nodToIndexElement[N];		// [nod] = indexElement
int heap[N];

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

inline int leftSon(int nod)
{
	return nod * 2;
}

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

inline int getMin()
{
	return heap[1];
}

void sift(int nod, int n)
{
	// Alege un fiu mai mic ca tatal
	int son = 0;

	if (leftSon(nod) <= n)
	{
		son = leftSon(nod);
	}

	if (rightSon(nod) <= n && heap[rightSon(nod)] < heap[son])
	{
		son = rightSon(nod);
	}

	if (heap[son] >= heap[nod])
	{
		son = 0;
	}

	if (son != 0)
	{
		swap(heap[son], heap[nod]);

		int indexElementSon = nodToIndexElement[son];
		int indexElementNod = nodToIndexElement[nod];

		indexElementToNod[indexElementNod] = son;
		nodToIndexElement[son] = indexElementNod;

		indexElementToNod[indexElementSon] = nod;
		nodToIndexElement[nod] = indexElementSon;

		sift(son, n);
	}
}

void percolate(int nod, int n)
{
	int val = heap[nod];

	int indexElementNod = nodToIndexElement[nod];

	while (nod > 1 && val < heap[father(nod)])
	{
		heap[nod] = heap[father(nod)];

		int indexElementFather = nodToIndexElement[father(nod)];
		indexElementToNod[indexElementFather] = nod;
		nodToIndexElement[nod] = indexElementFather;

		nod = father(nod);
	}

	heap[nod] = val;

	indexElementToNod[indexElementNod] = nod;
	nodToIndexElement[nod] = indexElementNod;
}

void deleteNode(int indexElement, int& n)
{
	int nod = indexElementToNod[indexElement];

	int indexElementN = nodToIndexElement[n];
	indexElementToNod[indexElementN] = nod;
	nodToIndexElement[nod] = indexElementN;

	heap[nod] = heap[n];
	n--;

	if (nod > 1 && heap[nod] < heap[father(nod)])
	{
		percolate(nod, n);
	}
	else
	{
		sift(nod, n);
	}
}

void insert(int value, int& n, int indexElement)
{
	n++;
	heap[n] = value;

	indexElementToNod[indexElement] = n;
	nodToIndexElement[n] = indexElement;

	percolate(n, n);
}

int main()
{
	int cerinte, n = 0, indexElement = 0;
	fin >> cerinte;

	for (int i = 0; i < cerinte; i++)
	{
		int cod;
		fin >> cod;

		if (cod == 1)
		{
			// insereaza x
			int x;
			fin >> x;

			indexElement++;
			insert(x, n, indexElement);
		}
		else if (cod == 2)
		{
			// se sterge al x-lea element intrat in multime
			int index;
			fin >> index;
			deleteNode(index, n);
		}
		else if (cod == 3)
		{
			// afiseaza element minim
			fout << getMin() << '\n';
		}
	}
}

/*

	9

	1 4		=> 4
	1 7		=> 4, 7
	1 9		=> 4, 7, 9

	3		=> min 4

	1 2		=> 4, 7, 9, 2
	2 1		=> 7, 9, 2

	3		=> min 2

	2 4		=> 7, 9

	3		=> min 7

*/