////arbore binar de cautare implementa cu pointeri
////creare ,adaugare, afisare ,cautare,stergere
////insereaza elemente distincte
//#include<fstream>
//using namespace std;
//ifstream fi("arb.in");
//ofstream fo("arb.out");
//struct Nod{
//int info;
//Nod *st,*dr;
//}*r;
//int i,n,x;
//void inserare_distincte(Nod*&r,int x){//inserare el. distincte
//Nod*q,*p=new Nod;
//p->info=x;
//p->st=0;
//p->dr=0;
//if(r==0){r=p;return;}
//q=r;
//while(1){
//    if(q->info==x){delete p;return;}
//    if(x<q->info)
//        if(q->st)q=q->st;
//        else {q->st=p; return;}
//    else
//        if(q->dr)q=q->dr;
//        else {q->dr=p; return;}
//    }
//}
//void inserare(Nod*&r,int x){//inserare el. oarecare(se pot repeta)
//Nod*q,*p=new Nod;
//p->info=x;
//p->st=0;
//p->dr=0;
//if(r==0){r=p;return;}
//q=r;
//while(1){
//    if(x<=q->info)
//        if(q->st)q=q->st;
//        else {q->st=p; return;}
//    else
//        if(q->dr)q=q->dr;
//        else {q->dr=p; return;}
//    }
//}
//void afisare(Nod*r){
//if(r){
//    afisare(r->st);
//    fo<<r->info<< " ";
//    afisare(r->dr);
//}
//}
//int cautare(Nod*r,int x){
//if(r){
//        if(x==r->info)return 1;
//        else if(x<r->info)cautare(r->st,x);
//             else cautare(r->dr,x);
//    }
//    else return 0;
//}
//void sterge(Nod*&r,int x){   //stergere nod de valoare x
//Nod *p,*t=0,*tmax,*max,*fiu;
//p=r;
//while(p and p->info!=x){
//        t=p;
//        if(x<p->info)p=p->st;
//        else p=p->dr;
//    }
//if(p==0)return; //nu este nodul x in arbore
//if(p->st and p->dr)  //nodul de sters are 2 fii
//{   //se determina maximul din subarborele stang
//    tmax=p;
//    max=p->st;
//    while(max->dr){
//        tmax=max;
//        max=max->dr;
//    }
//    p->info=max->info;//copiez informatia
//    t=tmax;//sterg nodul max
//    p=max;
//}
////nodul care va fi sters are cel mult un nod
//if(p->st)fiu=p->st;
//  else fiu=p->dr;
//if(t)
//   if(t->st==p)t->st=fiu;//p este fiu stang al tatalui
//   else t->dr=fiu;       //p este fiu drept al tatalui
// else r=fiu;  //sterg radacina
// delete p;
//}
////echilibrare
//int main(){
//    r=0;
//    fi>>n;
//    for(i=1;i<=n;i++)
//        {fi>>x;
//         inserare(r,x);
//        }
//    afisare(r);
////    sterge(r,1);sterge(r,34);
////     fo<<endl;afisare(r);
//   //fo<<endl<<cautare(r,41);
//return 0;
//}

////5  infoarena 90p
//////----------------------------------------------------
//////infoarena heapuri  (rezolvare cu Arbore binar de cautare (manual - fara echilibrare)
//// (pica un test -timp depasit )
////https://www.infoarena.ro/problema/heapuri
////Fie o multime de numere naturale initial vida.
////Se cere sa se efectueze N operatii asupra acestei multimi, unde operatiile
//// sunt de tipul celor de mai jos:
////
////operatia de tipul 1: se insereaza elementul x in multime
////operatia de tipul 2: se sterge elementul intrat al x-lea in multime,
////                     in ordine cronologica
////operatia de tipul 3: se afiseaza elementul minim din multime
//#include <fstream>
//#define M 200003
//using namespace std;
//ifstream fi("heapuri.in");
//ofstream fo("heapuri.out");
//struct Nod{
//int info;
//Nod *st,*dr;
//}*r;
//int i,n,x,m,op,j,a[M];
//
//void inserare(Nod*&r,int x){//inserare el. oarecare(se pot repeta)
//Nod*q,*p=new Nod;
//p->info=x;
//p->st=0;
//p->dr=0;
//if(r==0){r=p;return;}
//q=r;
//while(1){
//    if(x<=q->info)
//        if(q->st)q=q->st;
//        else {q->st=p; return;}
//    else
//        if(q->dr)q=q->dr;
//        else {q->dr=p; return;}
//    }
//}
//int minim(Nod*r){  //minimul este cel mai din stanga nod
//while(r->st)r=r->st;
//return r->info;
//}
//void sterge(Nod*&r,int x){   //stergere nod de valoare x
//Nod *p,*t=0,*tmax,*max,*fiu;
//p=r;
//while(p and p->info!=x){
//        t=p;
//        if(x<p->info)p=p->st;
//        else p=p->dr;
//    }
//if(p==0)return; //nu este nodul x in arbore
//if(p->st and p->dr)  //nodul de sters are 2 fii
//{   //se determina maximul din subarborele stang
//    tmax=p;
//    max=p->st;
//    while(max->dr){
//        tmax=max;
//        max=max->dr;
//    }
//    p->info=max->info;//copiez informatia
//    t=tmax;//sterg nodul max
//    p=max;
//}
////nodul care va fi sters are cel mult un nod
//if(p->st)fiu=p->st;
//  else fiu=p->dr;
//if(t)
//   if(t->st==p)t->st=fiu;//p este fiu stang al tatalui
//   else t->dr=fiu;       //p este fiu drept al tatalui
// else r=fiu;  //sterg radacina
// delete p;
//}
//int main()
//{
//    fi >> m;
//    for(i=1;i<=m;i++){
//       fi >> op;
//       if(op==1){ n++; fi>>a[n]; inserare(r,a[n]); }
//       if(op==2){ fi>>j; sterge(r,a[j]); }
//       if(op==3){ fo<<minim(r)<<'\n'; }
//    }
//    fi.close(); fo.close();
//    return 0;
//}
/*
Conteinerul set este o multime(elemente distincte!!).
Memorarea se face pe arbore de cautare echilibrat!!!.
Operatiile se fac in O(log(n)!!!!)
Parcurgerea in inordine de sirul ordonat crescator(iterator).
(sau descrescator cu reverse_iterator)
operatii: toate in O(log(n)!!!!
a.insert(x)  - adauga element daca este diferit de cele din multime EVIDENT!!!!!!
a.erase(it)  - sterge elementul indicat de it
a.erase(x)  - strege elementul x daca exista si returneaza 1
              si zero daca nu exista elementul
a.find(x)   - cauta elementul x si returneaza un iterator la el
a.begin()  a.end()   a.rbegin()  a.rend()
*/
//infoarena 80p
//////----------------------------------------------------
//////infoarena heapuri  (rezolvare cu Arbore binar de cautare STL
//// (pica 2 teste  - timp depasit)
//////infoarena heapuri  (rezolvare cu Arbore binar de cautare (manual - fara echilibrare)
//// (pica un test ca nu e echilibrat!!)
////https://www.infoarena.ro/problema/heapuri
////Fie o multime de numere naturale initial vida.
////Se cere sa se efectueze N operatii asupra acestei multimi, unde operatiile
//// sunt de tipul celor de mai jos:
////
////operatia de tipul 1: se insereaza elementul x in multime
////operatia de tipul 2: se sterge elementul intrat al x-lea in multime,
////                     in ordine cronologica
//////operatia de tipul 3: se afiseaza elementul minim din multime
#include <fstream>
#include <set>
#define M 200003
using namespace std;
ifstream fi("heapuri.in");
ofstream fo("heapuri.out");
int i,n,m,op,j,a[M];
set <int> arb;   //arb este o multime de elemente int
int main()
{
    fi >> m;
    for(i=1;i<=m;i++){
       fi >> op;
       if(op==1){ n++; fi>>a[n]; arb.insert(a[n]); }
       if(op==2){ fi>>j; arb.erase(a[j]); }
       if(op==3){ fo<<*arb.begin()<<'\n'; }
    }
    fi.close(); fo.close();
    return 0;
}