#include <fstream>
#include <vector>
#include <limits.h>
#include <iostream>
using namespace std;

typedef unsigned  long int ulong;

ulong n;
int v, w;

template<typename T>
class heap{
public:
    heap() {}
    inline T getMin() const { return heapA[0];}
    inline size_t left(size_t index) const { return 2*index+1; }
    inline size_t right(size_t index) const { return 2*index+2; }
    inline size_t parent(size_t index) const { return (index-1)/2; }
    inline size_t get_poz(size_t p_index) const { return poz[p_index]; }

    void push(T t);
    void minHeapify(size_t index);
    void decreaseKey(size_t index, T val);
    void popMin() { heapA[0] = heapA[heapA.size()-1]; poz[heapA.size()-1] = 0; heapA.pop_back(); minHeapify(0); }
    ~heap() {}
private:
    vector<T> heapA;
    vector<T> poz;
};

template<typename T>
void heap<T>::push(T t)
{
    heapA.push_back(t);
    poz.push_back(heapA.size()-1);

    size_t i = heapA.size()-1;
    while(i&&heapA[parent(i)] > heapA[i])
    {
        swap(heapA[parent(i)], heapA[i]);
        poz[parent(i)] = i;
        poz[i] = parent(i);
        i = parent(i);
    }
}

template<typename T>
void heap<T>::minHeapify(size_t index)
{
    size_t mn = index;
    if(left(index)  <  heapA.size() && heapA[left (index)]<heapA[mn]) mn=left (index);
    if(right(index) <  heapA.size() && heapA[right(index)]<heapA[mn]) mn=right(index);
    if(mn!=index)
    {
        swap(heapA[mn], heapA[index]);
        swap(poz[mn], poz[index]);
        minHeapify(mn);
    }
}

template<typename T>
void heap<T>::decreaseKey(size_t index, T val)
{
    heapA[index] = val;
    size_t i = index;
    while(i&&heapA[parent(i)] > heapA[i])
    {
        swap(heapA[parent(i)], heapA[i]);
        swap(poz[parent(i)], poz[i]);
        i = parent(i);
    }
}

int main()
{
    ios_base::sync_with_stdio(false);
    ifstream f("heapuri.in");
    ofstream g("heapuri.out");

    heap<long> h;

    f >> n;
    for(ulong i = 0; i < n; i++)
    {
        f >> v;
        switch(v)
        {
            case 1:
                f >> w;
                h.push(w);
                break;
            case 2:
                f >> w;
                h.decreaseKey(h.get_poz(w-1), -1);
                h.popMin();
                break;
            case 3:
                g << h.getMin() << '\n';
                break;
            default:
                break;
        }
    }

    return 0;
}