#include <iostream>
#include <fstream>
#include <cstdio>
#include <algorithm>

using namespace std;

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

class Heap{

	private:
		int* values;
		int* chrono;
		int* justinsert;
		int dimVect;
		int capVect;
		int index;
	public:
		Heap( int capVect ){
			this->capVect = capVect;
			dimVect = 1;
			index = 1;
			values = new int[this->capVect];
			chrono = new int[this->capVect];
			justinsert = new int[this->capVect];
		}
		
		~Heap(){
			
			delete[] values;
			delete[] chrono;
		}
		
		int parent( int i ){
		
			return i/2;
		}
		
		int LeftSubTree( int i ){
			return 2*i;
		}
		
		int RightSubTree( int i ){
			return 2*i+1;
		}
		
		void pushUp( int poz ){
		
			int parent = poz / 2;
			
			while( parent > 1 && values[parent] > values[poz] ){
				swap( values[parent], values[poz] );
				swap( chrono[values[parent]], chrono[values[poz]] );
				
				poz = parent;
				parent = poz / 2;
			}
		}
		
		void pushDown( int poz ){
		
			while(1){
				if( 2*poz + 1 > dimVect - 1 ){
					if( 2*poz > dimVect - 1 )
						break;
					else if( values[2*poz] < values[poz] ){
						swap( values[2*poz], values[poz] );
						swap( chrono[values[2*poz]], chrono[values[poz]] );
						poz = 2*poz;
						
					}
					else
						break;
				}
				else{
					if( values[2*poz] < values[poz] && values[2*poz] < values[2*poz+1] ){
						swap( values[2*poz], values[poz] );
						swap( chrono[values[2*poz]], chrono[values[poz]] );
						poz = 2*poz;
					}
					else if( values[2*poz+1] < values[poz] && values[2*poz+1] < values[2*poz] ){
						swap( values[2*poz+1], values[poz] );
						swap( chrono[values[2*poz+1]], chrono[values[poz]] );
						poz = 2*poz+1;
					}
					else
						break;
				}
			}
		}
		
		void insert( int x ){
		
			chrono[x] = index;
			values[dimVect] = x;
			justinsert[index] = x;
			dimVect++;
			index++;
			pushDown(dimVect-1);
		
		}
		
		int peek(){
			return values[1];
		}
		
		int extractMin(){
			int aux = values[1];
			values[1] = values[dimVect-1];
			dimVect--;
			pushDown(1);
			return aux;
		}
		 
		void deleteElement( int poz ){
		
			//values[poz] = values[dimVect-1];
			swap( values[poz], values[dimVect-1] );
			swap( chrono[values[poz]], chrono[values[dimVect-1]] );
			
			dimVect--;
			
			if( poz > 1 && values[poz] < values[parent(poz)] )
				pushUp(poz);
			else
				pushDown(poz);
		}
		
		void deleteByChronoIndex( int index ){
		
			int x = justinsert[index];
			int poz = chrono[x];
			deleteElement(poz);
		}
};

int main(){

	Heap h(10000000);

	int cod, x, N;
	in >> N;
	for( int i = 1; i <= N; i++ ){
		in >> cod;
		switch( cod ){
		
			case 1 :
				in >> x;
				h.insert(x);
				break;
			case 2 :
				in >> x;
				h.deleteByChronoIndex( x );
				break;
			case 3 :
				out<< h.peek() << endl;
				break;
			default:
				break;
		}
	}
		
	
	return 0;
	
	}