#include <fstream>
#include <vector> 
using namespace std;

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

int n;
//heapul propriu-zis
vector<int>heap;

//poozitiile elementelor in heap fata in functie de pozitiile lor initiale
vector<int> indexHeap;

//pozitiile elem in heap in functie de ordinea citirii
vector<int>pozitiiInitiale;

void ascendHeap()
{
	//elementul de pe pozitia heap.size() vreau sa ii dau ascend in heap
	int p = heap.size() - 1;
	while (p / 2 >= 0 && heap[p] < heap[p / 2])
	{
		int val = heap[p / 2];
		heap[p / 2] = heap[p];
		heap[p] = val;

		val = indexHeap[p / 2];
		indexHeap[p / 2] = indexHeap[p];
		indexHeap[p] = val;
		

		val = pozitiiInitiale[indexHeap[p / 2]];
		pozitiiInitiale[indexHeap[p / 2]] = pozitiiInitiale[indexHeap[p]];
		pozitiiInitiale[indexHeap[p]] = val;
		p = p / 2;

	}
}

void descendHeap(int pozitie)
{
	while (2 * pozitie < heap.size())
	{
		int t = pozitie;
		if (heap[t] > heap[2 * pozitie])
		{
			t = 2 * pozitie;
		}
		if (2 * pozitie + 1 < heap.size() &&
			heap[t] > heap[2 * pozitie + 1])
		{
			t = 2 * pozitie + 1;
		}
		if (t != pozitie)
		{
			//interschimb
			swap(heap[t], heap[pozitie]);
			swap(indexHeap[t], indexHeap[pozitie]);
			swap(pozitiiInitiale[indexHeap[t]], pozitiiInitiale[indexHeap[pozitie]]);

			pozitie = t;
		}
		else
		{
			break;
		}
	}

	
}

void afis() {
	for (int i = 0; i < heap.size(); i++)
	{
		fout << heap[i] << " ";
	}
	fout << endl;

	for (int i = 0; i < indexHeap.size(); i++)
	{
		fout << indexHeap[i] << " ";
	}
	fout << endl;

	for (int i = 0; i < pozitiiInitiale.size(); i++)
	{
		fout << pozitiiInitiale[i] << " ";
	}
	fout << endl;
}

int main()
{
	fin >> n;
	for (int i = 1; i <= n; i++)
	{
		int op;
		fin >> op;
		switch (op)
		{
		case 1: {
			int x;
			//adaug in heap;
			fin >> x;

			heap.push_back(x);
			indexHeap.push_back(heap.size() - 1);
			pozitiiInitiale.push_back(heap.size() - 1);
			ascendHeap();
			break;
		}
		case 2: {
			int x;
			fin >> x;
			x--;//lucrez cu poz 0
			//elimin elementul de pe pozitia x

			int lungime = heap.size() - 1;
			int changed = pozitiiInitiale[x];

			int val = heap[changed];
			heap[changed] = heap[lungime];
			heap[lungime] = val;
			

			val = indexHeap[changed];
			indexHeap[changed] = indexHeap[lungime];
			indexHeap[lungime] = val;
			
			pozitiiInitiale[indexHeap[lungime]] = changed;
			pozitiiInitiale[x] = -1;

			heap.pop_back();
			indexHeap.pop_back();

			descendHeap(changed);
			break;
		}
		default: {
			fout << heap[0]<<endl;
			break;
		}
		}
		//afis();
		//fout << "\n\n";
	}

	

}