#include <iostream>
#include <fstream>
using namespace std;
ifstream in("heapuri.in");
ofstream out("heapuri.out");


int order[200010]={};
class Heaps
{
    int *a;
    int length;
    int capacity;
public:
    Heaps(int);
    Heaps(const Heaps&);
    ~Heaps();
    inline int Parent(int i)
    {
        return a[(i-1)/2];
    }
    inline int rightChild(int i)
    {
        if(2*i+2<length)
            return a[2*i+2];
        return -1;
    }
    inline int  leftChild(int i)
    {
        if(2*i+1<length)
            return a[2*i+1];
        return -1;
    }
    inline int findMin()
    {
        return a[0];
    }
    int removeMin();
    void insertNode(int);
    void minHeapify(int);
    void minHeapifyUp(int);
    void decreaseKey(int, int);
    void deleteKey(int);
    void display();
    int pozitie(int);

};
void Heaps::display()
{

}
void Heaps::decreaseKey(int value,int i)
{
    a[i]-=value;
    minHeapifyUp(i);
}
Heaps::Heaps(int MAX_SIZE)
{
    length=0;
    capacity=MAX_SIZE;
    a=new int[MAX_SIZE];
}
Heaps::Heaps(const Heaps&old):capacity(old.capacity),length(old.length)
{
    a=new int[capacity];
    for(int i=0; i<length; i++)
        a[i]=old.a[i];

}
void Heaps::minHeapify(int i)
{
    int left,right,little;
    left=2*i+1;
    right=2*i+2;
    little=i;
    if (left<length)
    {
        if(a[left]
                <a[i])
            little=left;
        else
            little=i;
    }
    if (right<length)
    {
        if (a[right]
                <a[little])
            little=right;
    }
    if(i!=little)
    {

        std::swap(a[little],a[i]);
        minHeapify(little);

    }

}
void Heaps::minHeapifyUp(int i)
{

    if(i!=0)
    {

        int parent;
        parent=(i-1)/2;
        if (a[parent]>a[i])
        {
            std::swap(a[parent],a[i]);

            minHeapifyUp(parent);
        }


    }

}
int Heaps::removeMin()
{
    if(length==1)
    {
        length=0;
        return a[0];
    }
    int Min=a[0];
    a[0]=a[length-1];
    length--;
    minHeapify(0);
    return Min;
}
void Heaps::insertNode(int value)
{
    if(capacity==length)
        throw("Overflow error");

    a[length]=value;
    order[length+1]=value;
    length++;
    minHeapifyUp(length-1);

}
int Heaps::pozitie(int j)
{
    int ok=0;
    for(int i=0;i<length;i++)
        if(order[j]==a[i])
        return i;
}
void Heaps::deleteKey(int i)
{
    decreaseKey(a[pozitie(i)]+findMin()+1,pozitie(i));///transformam nodul in root
    removeMin();

}
Heaps::~Heaps()
{
    delete []a;
}
int main()
{
    int N;
    in>>N;
    Heaps H(200010);
    for(int i=0; i<N; i++)
    {
        int opt;
        in>>opt;
        switch(opt)
        {
        case 1:
        {
             int y;
            in>>y;
            H.insertNode(y);
            break;

        }
        case 2:
        {
            int y;
            in>>y;
            H.deleteKey(y);
            break;
        }
        case 3:
        {
            out<<H.findMin()<<"\n";
            break;
        }
        }

    }
    return 0;
}