#include <iostream>
#include<bits/stdc++.h>

using namespace std;

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

const int oo=(1<<31)-1;

void push(int);
int LChild(int);
int RChild(int);
int get();
void climb_up(int);
void climb_down(int);
void pop(int);

vector<int> heap(1,0);
vector<int> value(1,-1);
vector<int> PositionInHeap(1,0);


int main()
{
    int n,x,cod;
    f>>n;
    for(;n;n--)
    {
        f>>cod;
        if(cod==1)
        {
            f>>x;
            push(x);
        }
        else if(cod==2)
        {
            ///for(auto it:PositionInHeap) g<<it<<' ';
            ///g<<endl;
            f>>x;
            pop(PositionInHeap[x]);
        }
        else if(cod==3)
        {
            g<<get()<<endl;
        }
    }
    return 0;
}


void push(int x)
{
    value.push_back(x);
    heap.push_back(value.size()-1);
    int k=heap.size()-1;
    PositionInHeap.push_back(k);
    climb_up(k);
}

int LChild(int i)
{
    if(i*2<=heap.size()-1)
    return value[heap[i*2]];
    return oo;
}

int RChild(int i)
{
    if(i*2+1<=heap.size()-1)
        return value[heap[i*2+1]];
    return oo;
}

int get()
{
    return value[heap[1]];
}

void climb_up(int k)
{
    while(value[heap[k/2]]>value[heap[k]])
    {
        swap(PositionInHeap[heap[k/2]],PositionInHeap[heap[k]]);
        swap(heap[k/2],heap[k]);
        k/=2;
    }
}

void climb_down(int k=1)
{
    while(RChild(k)<value[heap[k]] || LChild(k)<value[heap[k]])
    {
        if(RChild(k)<LChild(k))
            {
                swap(PositionInHeap[heap[k]],PositionInHeap[heap[k*2+1]]);
                swap(heap[k*2+1],heap[k]);
                k=k*2+1;
            }
        else
            {
                swap(PositionInHeap[heap[k]],PositionInHeap[heap[k*2]]);
                swap(heap[k*2],heap[k]);
                k=k*2;
            }
    }
}

void pop(int i)
{
    heap[i]=heap[heap.size()-1];
    heap.pop_back();
    if(value[heap[i/2]]>value[heap[i]])climb_up(i);
    else climb_down(i);
}