#include <fstream>
#include <vector>
#include <cmath>
#include <iostream>
#include <map>
using namespace std;

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

const int CAPACITY = 200001;

void swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

class Heap
{

private:
    int val[CAPACITY];
    int kth[CAPACITY];
    int length = 0;
    int count = 0;
    int kthIndex[CAPACITY];

    int left(int idx)
    {
        return idx * 2 + 1;
    }

    int right(int idx)
    {
        return idx * 2 + 2;
    }

    int parent(int idx)
    {
        return (idx - 1) / 2;
    }

    void swapNodes(int idx0, int idx1)
    {
        swap(kthIndex[kth[idx0]], kthIndex[kth[idx1]]);
        swap(kth[idx0], kth[idx1]);
        swap(val[idx0], val[idx1]);
    }

    void heapUp(int idx)
    {
        if (idx == 0)
        {
            return;
        }
        int parentIdx = parent(idx);
        if (val[idx] < val[parentIdx])
        {
            swapNodes(idx, parentIdx);
            heapUp(parentIdx);
        }
    }

    void heapDown(int idx)
    {
        int lIdx = left(idx);
        int rIdx = right(idx);
        if (lIdx >= length)
        {
            return;
        }
        int minIdx = idx;
        if (val[lIdx] < val[minIdx])
        {
            minIdx = lIdx;
        }
        if (rIdx < length && val[rIdx] < val[minIdx])
        {
            minIdx = rIdx;
        }
        if (idx != minIdx)
        {
            swapNodes(idx, minIdx);
            heapDown(minIdx);
        }
        else
        {
            heapUp(minIdx);
        }
    }

    void deleteByIdx(int idx)
    {
        int lastIdx = length - 1;
        swapNodes(idx, lastIdx);
        --length;
        heapDown(idx);
    }

public:
    void addVal(int newVal)
    {
        int idx = length;
        val[idx] = newVal;
        kth[idx] = ++count;
        kthIndex[count] = idx;
        ++length;
        heapUp(idx);
    }

    int top()
    {
        return val[0];
    }

    void removeKth(int k)
    {
        deleteByIdx(kthIndex[k]);
    }
};

int main()
{
    int t, val, op, k;
    Heap h;
    fin >> t;
    while (t-- > 0)
    {
        fin >> op;
        if (op == 1)
        {
            fin >> val;
            h.addVal(val);
        }
        else if (op == 2)
        {
            fin >> k;
            h.removeKth(k);
        }
        else if (op == 3)
        {
            fout << h.top() << "\n";
        }
    }
    return 0;
}