#define REP(a,b) for(int a=0; a<(b); ++a)
#define FWD(a,b,c) for(int a=(b); a<(c); ++a)
#define FWDS(a,b,c,d) for(int a=(b); a<(c); a+=d)
#define BCK(a,b,c) for(int a=(b); a>(c); --a)
#define ALL(a) (a).begin(), (a).end()
#define SIZE(a) ((int)(a).size())
#define VAR(x) #x ": " << x << " "
#define x first
#define y second
#define st first
#define nd second
#define pb push_back
#define nleft (n<<1)
#define nright (nleft+1)
#define nfather n>>1

#include<vector>

using namespace std;
#include<fstream>
ifstream fin("heapuri.in");
ofstream fout("heapuri.out");

#define NMAX 1000000

typedef long long LL;
typedef pair<int, int> PII;
typedef long double K;
typedef pair<K, K> PKK;
typedef vector<int> VI;

class Heap{
	public:
 
	int Heap[NMAX], Val[NMAX], Pos[NMAX], N;
	 
	void down(int n) // Descendenta nodului pana la stabilirea echilibrului
	{
	    int son;
	    do{
	        son=0;
	        
	        // Alegem nodul: son={nleft, nright, 0}
	        if(nleft<=N){
	            son=nleft;
	            if(nright<=N && Val[Heap[nright]]<=Val[Heap[nleft]])
	                son=nright;
	                
	            if(Val[Heap[son]]>=Val[Heap[n]])
	                son=0;
	        }
	        
	        if(son)
	        {
	            swap(Heap[n], Heap[son]);
	            Pos[Heap[n]]=n;
	            Pos[Heap[son]]=son;
	            n=son; // Cernem mai departe recursiv
	        }
	    }while(son);
	}
	 
	void up(int n) //Urcam nodul pana se stabileste echilibrul
	{
	    int key=Heap[n];
	     
	    while(n>1 && Val[key]<Val[Heap[nfather]]) // Urcam in arbore recursiv
	    {
	        Heap[n]=Heap[nfather];
	        Pos[Heap[n]]=n;
	        n=nfather;
	    }
	     
	    Heap[n]=key; // La ultimul nod urcat atribuim cheia
	    Pos[key]=n;
	}
	 
	void build_heap() // Sortam heap-ul
	{
	    for(int i=(N>>1); i>0; --i)
	        down(i);
	}
	
	int get_pos(int val)
	{
		return Pos[val];
	}
	
	int head()
	{
		return Val[Heap[1]];
	}
	 
	void erase(int n) // Stergerea unui element in O(logn), K - pozitia K in Heap
	{
	    Heap[n]=Heap[N];
	    --N;
	    if(n>1 && Val[Heap[n]]<Val[Heap[nfather]])
	        up(n);
	    else
	        down(n);
	}
	 
	void insert(int key, int val)
	{
		Val[key]=val;
	    Heap[++N]=key;
	    Pos[Heap[N]]=N;
	    up(N);
	}
};

int t,a,b,i;
Heap A;
 
int main()
{
    fin>>t;
    i=1;
    while(t--)
    {
        fin>>a;
         
        switch(a)
        {
            case 1:
                fin>>b;
                A.insert(i, b);
                ++i;
                break;
            case 2:
                fin>>b;
                A.erase(A.get_pos(b));
                break;
            case 3:
                fout<<A.head()<<"\n";
                break;
        }
    }
     
    return 0;
}