#include<iostream>
#include<fstream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<bitset>
#include<cstring>

#define ull unsigned long long
#define ll long long
#define pb push_back
#define FOR(a,b,c) for (int a=b;a<=c; ++a)
#define ROF(a,b,c) for (int a=b;a>=c; --a)

using namespace std;
ifstream f("heapuri.in");
ofstream g("heapuri.out");
int M,N,nrord;
int v[200005],ord[200005],opord[200005]; // v=heap-ul, ord[i]=ce ordine de introducere are elementul de pe pozitia i, opord[i]=pe ce pozitie se afla elementul cu ordinea i

inline int firstson(int);
inline int secondson(int);
inline int dad(int);
inline void percolate(int);
inline void sift(int);
inline void inser(int);

int main()
{
    N=0;
    f>>M;
    while (M--)
    {
        int tip;
        f>>tip;
        if (tip==1) {
            int x;
            f>>x;
            inser(x);
        }
        else if (tip==2) {
            int x;
            f>>x;
            x=opord[x];
            swap(opord[ord[x]],opord[ord[N]]);
            swap(ord[x],ord[N]);
            swap(v[x],v[N]);
            N--;
            if (v[x]<v[dad(x)] && x!=1)
                percolate(x);
            else
                sift(x);
        }
        else {
            g<<v[1]<<'\n';
        }
    }
    f.close();g.close();
    return 0;
}


inline int firstson(int n)
{
    return 2*n;
}

inline int secondson(int n)
{
    return 2*n+1;
}

inline int dad(int n)
{
    return n/2;
}

inline void percolate(int n)
{
    int val=v[n];
    while (n>1 && val<v[dad(n)])
    {
        swap(opord[ ord[dad(n)] ] , opord[ ord[n] ]);
        swap(ord[dad(n)],ord[n]);
        v[n]=v[dad(n)];
        n=dad(n);
    }
    v[n]=val;
}

inline void sift(int n)
{
    int son;
    do {
        son=0;
        if (firstson(n)<=N)
        {
            son=firstson(n);
            if (secondson(n)<=N && v[secondson(n)]<v[firstson(n)])
                son=secondson(n);
            if (v[son]>=v[n])
                son=0;
        }
        if (son) {
            swap(opord[ ord[son] ] , opord[ ord[n] ]);
            swap(ord[son],ord[n]);
            swap(v[son],v[n]);
            n=son;
        }
    }
    while (son);
}

inline void inser(int elem)
{
    v[++N]=elem;
    ord[N]=++nrord;
    opord[nrord]=N;
    percolate(N);
}