/*
HEAP-URI:
====================
priority_queue<int> myheap;
myheap.push(x);     //inserare
myheap.pop();       //cel mai mere element
myheap.top();       //stergere

cerinta: minimul din heap?
    1. inmultim cu -1;
cerinta: sterge elem din interior?
    1. al 2-lea pq in care tin elem sterse;
    2. tine un map cu ce elem trebuie sters;
    ex: 3 5 7 10 12
    mymap[7] = 1;   //trebuie sters!
    mymap[7] = 0;   //s-a sters elementul :)

====================
set<int> myset;
myset.insert(x);
myset.erase(...);   //de iterator sau de valoare
myset.begin()       //cel mai mic(iteratorul)
myset.end()         //poz de dupa cel mai mare

myset.erase(myset.find(5))  //sterge primul 5 gasit
myset.erase(5)              //sterge toate val = 5

SET ESTE MAI PUTERNIC!! -dar merge ft ft ft incet

====================
- arbore binar partial complet
- raspunsul este in radacina
- minheap - valoarea dintr-un nod va fi mai mica decat valoarea fiilor
*/

/*
#include <iostream>
#include <fstream>
#define N 200005
#include <set>

using namespace std;

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

int n, v[N];
set<int> myset;
set<int>::iterator itr;

int main()
{
    int i, op, x, k = 0;
    fin >> n;
    for(i = 1; i <= n; i++)
    {
        fin >> op;
        if(op == 1)
        {
            fin >> x;
            v[++k] = x;
            myset.insert(x);
        }
        else if(op == 2)
        {
            fin >> x;
            myset.erase(v[x]);
        }
        else if(op == 3)
        {
            itr = myset.begin();
            fout << *itr << "\n";
        }
    }
    return 0;
}
*/

///======= implementare de mana =======///

#include <iostream>
#include <fstream>
#include <vector>
#define N 200005
 
using namespace std;
 
ifstream fin ("heapuri.in");
ofstream fout ("heapuri.out");
 
int v[N], heap[N], poz[N];
int ct = 0;
 
void insert(int i)
{
	while (i > 1 && v[heap[i]] < v[heap[i / 2]])
	{
		swap(heap[i], heap[i / 2]);
		poz[heap[i]] = i;
		poz[heap[i / 2]] = i / 2;
		i /= 2;
	}
}

void del(int i)
{
	int st = 2 * i;
	int dr = 2 * i + 1;
	int min = i;
	do {
		i = min;
		st = 2 * i;
		dr = 2 * i + 1;
		if (st <= ct && v[heap[st]] < v[heap[min]])
		{
			min = st;
		}
		if (dr <= ct && v[heap[dr]] < v[heap[min]])
		{
			min = dr;
		}
		swap(heap[i], heap[min]);
		poz[heap[i]] = i;
		poz[heap[min]] = min;
	} while (min != i);
}
 
int main()
{
	int n, op, x, i;
	fin >> n;
	for (i = 0; i < n; ++i)
	{
		fin >> op;
		if (op == 1)
		{
			fin >> x;
			v[++ct] = x;
			heap[ct] = ct;
			poz[ct] = ct;
			insert(ct);
		}
		if (op == 2)
		{
			fin >> x;
			int pozitie = poz[x];
			v[x] = 1000000001;
			del(pozitie);
		}
		if (op == 3)
		{
			fout << v[heap[1]] << '\n';
		}
	}
	return 0;
}