#include <bits/stdc++.h>

using namespace std ;
const int MAX = 2e5 + 14 ;

class Reader
{
    public:
        Reader() {}
        Reader(const char *file_name) {
            input_file = fopen(file_name, "r");
            cursor = 0;
            fread(buffer, SIZE, 1, input_file);
        }
        inline Reader &operator >>(int &n) {
            while(buffer[cursor] < '0' || buffer[cursor] > '9') {
                advance();
            }
            n = 0;
            while('0' <= buffer[cursor] && buffer[cursor] <= '9') {
                n = n * 10 + buffer[cursor] - '0';
                advance();
            }
            return *this;
        }
    private:
        FILE *input_file;
        static const int SIZE = 1 << 17;
        int cursor;
        char buffer[SIZE];
        inline void advance() {
            ++ cursor;
            if(cursor == SIZE) {
                cursor = 0;
                fread(buffer, SIZE, 1, input_file);
            }
        }
};

class Writer
{
public:
    Writer(const char *name):
        m_stream(name)
    {
        memset(m_buffer, 0, sizeof(m_buffer));
        m_pos = 0;
    }

    Writer& operator<<(int a)
    {
        int many = 0;
        do
        {
            digit_buffer[many++] = a % 10 + '0';
            a /= 10;
        }
        while (a > 0);
        for (int i = many - 1; i >= 0; --i)
            putchar(digit_buffer[i]);
        return *this;
    }

    Writer& operator<<(const char *s)
    {
        for (; *s; ++s)
            putchar(*s);
        return *this;
    }

    ~Writer()
    {
        m_stream.write(m_buffer, m_pos);
    }

private:
    void putchar(char c)
    {
        m_buffer[m_pos++] = c;
        if (m_pos == kBufferSize)
        {
            m_stream.write(m_buffer, m_pos);
            m_pos = 0;
        }
    }

    static const int kBufferSize = 1 << 17;
    ofstream m_stream;
    char m_buffer[kBufferSize];
    char digit_buffer[30];
    int m_pos;
};

Reader f ("heapuri.in") ;
Writer g("heapuri.out") ;

int v[MAX], h[MAX], n, sz ;
bool deleted[MAX] ;

void UpHeap (int nod)
{
    if ((nod>>1) == 0){
        return ;
    }
    if (v[h[nod>>1]]>v[h[nod]]) {
        swap (h[nod>>1], h[nod]) ;
        UpHeap (nod>>1) ;
    }
    return ;
}

void DownHeap (int nod)
{
    if (nod > sz) {
        return ;
    }
    if (nod * 2 <= sz and nod * 2 + 1 <= sz and v[h[nod*2]] < v [h[nod]] and v [h[nod*2+1]] < v[h[nod]]) {
        if (v[h[nod*2]] < v [h[nod*2+1]]) {
            swap (h[nod*2], h[nod]) ;
            DownHeap (nod * 2) ;
            return ;
        }
        swap (h[nod*2 + 1], h[nod]) ;
        DownHeap (nod * 2 + 1) ;
        return ;
    }
    if (nod * 2 <= sz and v[h[nod*2]] < v [h[nod]]){
        swap (h[nod*2], h[nod]) ;
        DownHeap (nod * 2) ;
        return ;
    }
    if (nod * 2 + 1 <= sz and v [h[nod*2+1]] < v[h[nod]]) {
        swap (h[nod*2 + 1], h[nod]) ;
        DownHeap (nod * 2 + 1) ;
        return ;
    }
    return ;
}

void TypeOne (int x)
{
    n += 1 ;
    v [n] = x ;
    sz += 1 ;
    h [sz] = n ;
    UpHeap (sz) ;
}

void TypeTwo (int x)
{
    deleted [x] = 1;
}

int TypeThree ()
{
    while (deleted [h[1]] == 1) {
        swap (h[sz], h[1]) ;
        sz -= 1 ;
        DownHeap (1) ;
    }
    return v[h[1]] ;
}

int main()
{
    int m ;
    f >> m ;
    while (m --){
        int type ;
        f >> type ;
        switch (type){
            int x ;
            case 1 :
                f >> x ;
                TypeOne (x) ;
                break ;
            case 2 :
                f >> x ;
                TypeTwo (x) ;
                break ;
            case 3 :
                g << TypeThree () << '\n' ;
                break ;
        }
    }
}