#include <iostream>
#include <fstream>
#include <queue>

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

struct myType{
    int data;
    int time;
};

class MaxBinaryHeap{
private:
    myType bHeap[200100];
    int N;
    int I;

    void swim(int k){
        while (k > 1 && bHeap[k].data < bHeap[k/2].data)
        {
            swap(bHeap[k], bHeap[k/2]);
            k = k/2;
        }
    }

    void sink(int k){
        while (2*k <= N)
        {
            int j = 2*k;
            if (j < N && bHeap[j].data < bHeap[j+1].data) j++;
            if (bHeap[k].data <= bHeap[j].data) break;
            swap(bHeap[j],bHeap[k]);
            k = j;
        }
    }

 public:
     MaxBinaryHeap(){
         N = 0;
         I = 0;
     }

     void add(int x){
        ++N; ++I;
        bHeap[N].data = x;
        bHeap[N].time = I;
        swim(N);
     }

 /*    bool isEmpty(){
        return N == 0;
     }

     int delMax(){
        int maxim = bHeap[1].data;
        swap(bHeap[1],bHeap[N]);
        bHeap[N].data = 0;
        --N;
        sink(1);
        return maxim;
     }
*/
     int minim()
     {
         return bHeap[1].data;
     }

 /*    void afis()
     {
         for(int i = 1; i <= N; ++i)
            fout<<bHeap[i].data<<' '<<bHeap[i].time<<endl;
        fout<<'\n';
     }
*/
     int delTime(int k)
     {
         for(int i = 1; i<=N; i++)
            if(bHeap[i].time == k)
         {
             swap(bHeap[i], bHeap[N]);
             --N;
             sink(i);
         }
     }
};

int i,n,x,y;
queue<int>q;
MaxBinaryHeap myHeap;

int main()
{
    fin>>n;
    for(int i = 1; i<=n; i++)
    {
        fin>>x;
        if(x == 1)
        {
            fin>>y;
            myHeap.add(y);
        }
        else if(x == 2)
        {
            fin>>y;
            myHeap.delTime(y);
        }
        else
            fout<<myHeap.minim()<<'\n';
    }

    return 0;
}