#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <fstream>
using namespace std;
 
const size_t MAXN = 200010;
// Heap data type and comparator.
typedef int heap_t;
inline bool cmp_heap(const heap_t &a, const heap_t &b)
{return a < b;}
// The data
heap_t data[MAXN]; // 1 based index
size_t size_data;
/* Contains the indexes of the data organized as
 * a min or a max heap, the top being at position 1.
 */
size_t heap[MAXN], size_heap;
// pos[i] is the position of data[i] in the heap.
size_t pos_heap[MAXN];
 
// Moves the element at heap[pos] up in the heap.
void heap_up(size_t pos)
{
    while (pos/2 && !cmp_heap(data[heap[pos/2]], data[heap[pos]]))
    {
        swap (heap[pos], heap[pos/2]);
        pos_heap[heap[pos]] = pos;
        pos_heap[heap[pos/2]] = pos/2;
        pos /= 2;
    }
}
// Moves the element at heap[pos] down in the heap.
void heap_down(size_t pos)
{
    size_t next;
    while (pos <= size_heap)
    {
        next = pos;
        if (2*pos <= size_heap && !cmp_heap(data[ heap[next] ], data[ heap[pos*2] ]))
            next = 2*pos;
        if (2*pos+1 <=  size_heap && !cmp_heap(data[ heap[next] ], data[ heap[pos*2+1] ]))
            next = 2*pos+1;
 
        if (next == pos) break;
 
        swap (heap[pos], heap[next]);
        pos_heap[heap[next]] = next;
        pos_heap[heap[pos]] = pos;
         
        pos = next;
    }
}
  
// Adds the element data[pos] to the heap.
void push_heap(const size_t pos)
{
    heap[++size_heap] = pos;
    pos_heap[pos] = size_heap;
    heap_up(size_heap);
}
// Returns the element at the top of the heap.
heap_t top_heap()
{ return data[heap[1]]; }
// This removes element data[pos] from the heap.
void delete_heap(size_t pos)
{
    pos = pos_heap[pos];
 
    swap(heap[pos], heap[size_heap]);
    pos_heap[heap[pos]] = pos;
    pos_heap[heap[size_heap]] = size_heap;
 
    size_heap -= 1;
 
    heap_down(pos);
}
// Removes the element at the top of the heap.
heap_t pop_heap()
{
    heap_t temp = data[heap[1]];
    delete_heap(1);
    return temp;
}
// Initializes the heap.
void init_heap(heap_t *data, const size_t size_data)
{
    for (size_t i = 1; i <= size_data; ++i)
        heap[i] = pos_heap[i] = i;
 
    size_heap = size_data;
    for (size_t i = size_data/2; i; --i)
        heap_down(i);
}
// After modifying data[pos] this maintains the heap propery.
void update_heap(size_t pos)
{
    pos = pos_heap[pos];
 
    heap_up(pos);
    heap_down(pos);
}
 
int main()
{
    ifstream fin("heapuri.in");
    ofstream fout("heapuri.out");
 
    size_t t, op, x;
    fin >> t;
 
    for (; t; --t)
    {
        fin >> op;
        switch(op)
        {
            case 1:
                fin >> x;
                data[++size_data] = x;
                push_heap(size_data);
 
                break;
            case 2:
                fin >> x;
                delete_heap(x);
 
                break;
            case 3:
                fout << top_heap() << '\n';
 
                break;
        }
    }
 
    fout.close();
    return EXIT_SUCCESS;
}