#include <stdio.h>
#define DIM 200005
typedef unsigned int uint;

class Heap
{ 
private:
    uint* values;
	int capVect;

public:
	int dimVect, numere;
    Heap(int capVect);
	
    ~Heap();
 
    int parent(int poz);
 
    int leftSubtree(int poz);
 
    int rightSubtree(int poz);
 
    void pushUp(int poz1,int poz2,int poz[]);   
 
    void insert(uint x,int poz[]);

    int minim(uint a,uint b);

	uint afisare();
 
    void erase(int k,int poz[]);
};


Heap::Heap(int capVect)
{
	this-> capVect = capVect;
	this->dimVect = -1;
	this->numere = -1;
	values = new uint[capVect];	
}

Heap::~Heap()
{
   delete[] values;
}

int Heap::parent(int poz)
{
    return (poz - 1) / 2;
}

int Heap::leftSubtree(int poz)
{
    if(poz * 2 +1 <= dimVect)
		return poz * 2 +1;
	else return -1;
}

int Heap::rightSubtree(int poz)
{
  	if(poz * 2 +2 <= dimVect)
		return poz * 2 +2;
	else return -1;
}

void Heap::pushUp(int poz1,int poz2,int poz[])
{
uint aux;
	aux = values[poz1];
	values[poz1] = values[poz2];
	values[poz2] = aux; 
	
int aux2;
	poz1 = poz[poz1];
	poz2 = poz[poz2];
	
	aux2 = poz[poz1];
	poz[poz1] = poz[poz2];
	poz[poz2] = aux2; 
}

void Heap::insert(uint x,int poz[])
{
uint poz_curent, poz_parinte;

    if(dimVect == -1)
	{
	values[0] = x;
	dimVect = 0;
	numere = 0;
	}
	else 
	{
	numere++;
	values[++dimVect] = x;
	
	poz_curent = dimVect;

	poz_parinte =  parent(poz_curent);
	while( values[ poz_parinte  ] > values[ poz_curent ] )
	{
		pushUp( poz_curent,  poz_parinte,poz );
		poz_curent = poz_parinte;
		
		if(poz_curent == 0)
			break;
		poz_parinte =  parent(poz_curent);		
	}	
	}
}

uint Heap::afisare()
{	
	return values[0];
}

int Heap::minim(uint a, uint b)
{
	if(values[a] < values[b]) return a;
	return b;   	
}

void Heap::erase(int k,int poz[])
{
uint poz_curent,aux,poz_stanga,poz_dreapta,fiu_cel_mare;
	
	aux = values[dimVect];
	values[dimVect] = values[k];
	values[k] = aux;

	dimVect--;
	poz_curent = k;

	poz_dreapta = rightSubtree(poz_curent);
	poz_stanga = leftSubtree(poz_curent);
	

	if(poz_dreapta < 0 && poz_stanga > 0)
		fiu_cel_mare = leftSubtree(poz_curent);
	else if(poz_dreapta > 0 && poz_stanga < 0)
		fiu_cel_mare = rightSubtree(poz_curent);
	else
		fiu_cel_mare = minim(poz_stanga,poz_dreapta);

	
	while( values[fiu_cel_mare] < values[poz_curent])
	{
		pushUp(fiu_cel_mare,poz_curent,poz);
		poz_curent = fiu_cel_mare;

	poz_dreapta = rightSubtree(poz_curent);

	poz_stanga = leftSubtree(poz_curent);
	
	if(poz_dreapta < 0 && poz_stanga > 0)
		fiu_cel_mare = leftSubtree(poz_curent);
	else if(poz_dreapta > 0 && poz_stanga < 0)
		fiu_cel_mare = rightSubtree(poz_curent);
	else if(poz_dreapta > 0 && poz_stanga > 0)
		fiu_cel_mare = minim(poz_stanga,poz_dreapta);
	else break;
	}
}

void citire()
{
	FILE *f=fopen("heapuri.in","r"), *g=fopen("heapuri.out","w");
	int i,N,op,nr=-1;
	uint x;
	Heap heap(DIM);
	int poz[DIM];
	
	fscanf(f,"%d",&N);
	
	for(i = 0; i < N; i++)
	{
		
		fscanf(f,"%d",&op);
		if( op == 3)
			fprintf(g,"%u\n",heap.afisare());
		else 
		{
			fscanf(f,"%ud",&x);
			if(op == 1)
			{
				poz[++nr] = nr;
				heap.insert(x,poz);
			}
			else
				heap.erase(poz[x-1],poz);
		}
	}
}

int main()
{
	citire();
	
return 0;
}