#include <fstream>

using namespace std;
ifstream f("hashuri.in");
ofstream g("hashuri.out");
struct nod
{
    int V;//valoare retinuta in nod - pe baza sa se formeaza structura de BST
    int N;//nivel - ajuta la echilibrarea arborelui
    nod *S,*D;
};
nod *root;
nod* ins(nod*,int);//insereaza valoare noua,returneaza aatree format prin inserare
nod* del(nod*,int);//sterge valoare, returneaza AA-tree format prin stergere
int succ(nod*);
int prec(nod*);
nod* skew(nod*);
nod* split(nod*);
nod* decN(nod*);
int caut(nod*,int);
int main()
{
    int n,i,j;
    f>>n;
    for(;n;n--)
    {
        f>>i>>j;
        if(i==1)
            root=ins(root,j);
        if(i==2)
            root=del(root,j);
        if(i==3)
            g<<caut(root,j)<<'\n';

    }
    return 0;
}
int caut(nod *T,int v)
{
    if(T==NULL)
        return 0;
    if(v<T->V)
        return caut(T->S,v);
    if(v>T->V)
        return caut(T->D,v);
    return 1;

}
nod *skew(nod* T)
{
    if(T==NULL)
        return NULL;
    if(T->S==NULL)
        return T;
    if(T->S->N==T->N)
    {
        nod *aux;
        aux=T->S;
        T->S=aux->S;
        aux->D=T;
        return aux;
    }
    return T;

}
nod *split(nod *T)
{
    if(T==NULL)
        return NULL;
    if(T->D==NULL||T->D->D==NULL)
        return T;
    if(T->N==T->D->D->N)
    {
        nod *aux;
        aux=T->D;
        T->D=aux->S;
        aux->S=T;
        aux->N=1+aux->N;
        return aux;
    }
    return T;
}
nod *ins(nod *T,int v)
{
    if(T==NULL)
    {
        nod *aux;
        aux=new nod;
        aux->V=v;
        aux->N=1;
        aux->S=aux->D=NULL;
        return aux;
    }
    if(v<T->V)
    {
        T->S=ins(T->S,v);
    }
    else
        if(v>T->V)
        {
            T->D=ins(T->D,v);

        }
    T=skew(T);
    T=split(T);
    return T;
}
nod *del(nod *T,int v)
{
    if(T==NULL)
        return T;
    if(v>T->V)
        T->D=del(T->D,v);
    else
        if(v<T->V)
            T->S=del(T->S,v);
        else
        if(T->S==NULL&&T->D==NULL)
        {
            delete T;
            T=NULL;
            return T;
        }

        else
        if(T->S==NULL)
        {
            int vaux;
            vaux=succ(T);
            T->V=vaux;
            T->D=del(T->D,vaux);

        }
        else
        {
            int vaux;
            vaux=prec(T);
            T->V=vaux;
            T->S=del(T->S,vaux);
        }
    T=decN(T);
    T=skew(T);
    T->D=skew(T->D);
    if(T->D!=NULL)
        T->D->D=skew(T->D->D);
    T=split(T);
    T->D=split(T->D);
    return T;
}
int succ(nod *T)
{
    nod *aux;
    aux=T->D;
    while(aux->S)aux=aux->S;
    return aux->V;
}
int prec(nod *T)
{
    nod *aux;
    aux=T->S;
    while(aux->D)aux=aux->D;
    return aux->V;
}
nod *decN(nod *T)
{
    if(T->S==NULL||T->D==NULL)
        return T;
    int nec=min(T->S->N,1+T->D->N);
    if(nec<T->N)
    {
        T->N=nec;
        if(nec<T->D->N)
            T->D->N=nec;
    }
    return T;
}