#include <bits/stdc++.h>
using namespace std;
ifstream fin("hashuri.in");
ofstream fout("hashuri.out");

int t,op,x;

struct avl
{
    int h,diff,val;
    avl *l, *r;

    avl()
    {
        h = 1, diff = 0,val = 0;
        l = NULL;
        r = NULL;
    }

};
avl *root;

avl* update(avl* nod)
{
    int hl = 0, hr = 0;
    if(nod->l != NULL) hl = nod->l->h;
    if(nod->r != NULL) hr = nod->r->h;

    nod->h = max(hl,hr) + 1;
    nod->diff = hl-hr;

    return nod;
}

avl* rotate_left(avl* nod)
{
    avl *aux = nod->r;
    nod->r = aux->l;
    aux->l = nod;

    nod = update(nod);
    return update(aux);
}

avl* rotate_right(avl* nod)
{
    avl *aux = nod->l;
    nod->l = aux->r;
    aux->r = nod;

    nod = update(nod);
    return update(aux);
}

avl* _balance(avl* nod)
{
    if(abs(nod->diff) <= 1) return nod;
    else
    {
        if(nod->diff == 2 && nod->l->diff >= 0) return rotate_right(nod);
        else if(nod->diff == 2 && nod->l->diff < 0)
        {

            nod->l = rotate_left(nod->l);
            return rotate_right(nod);
        }
        else if(nod->diff == -2 && nod->r->diff <= 0) return rotate_left(nod);
        else if(nod->diff == -2 && nod->r->diff >0)
        {
            nod->r = rotate_right(nod->r);
            return rotate_left(nod);
        }
    }
}

avl* _insert(avl* nod, int x)
{
    if(nod == NULL)
    {
        nod = new avl();
        nod->val = x;
        return nod;
    }
    if(nod->val == x) return nod;
    else if(x < nod->val)
    {

        nod->l = _insert(nod->l,x);
        nod = update(nod);
    }

    else
    {
        nod->r = _insert(nod->r,x);
        nod = update(nod);
    }

    return _balance(nod);

}

avl* _delete(avl* nod, int x)
{
    if(nod == NULL) return NULL;
    if(nod->val == x)
    {
        if(nod->l == NULL) return nod->r;
        else
        {
            avl* aux = nod->l;
            while(aux->r != NULL) aux = aux->r;
            nod->val = aux->val;
            nod->l = _delete(nod->l, aux->val);
            nod = update(nod);
        }

    }
    else
    {
        if(nod->val > x) nod->l = _delete(nod->l, x);
        else nod->r = _delete(nod->r, x);

        nod = update(nod);
    }

    return _balance(nod);

}

avl* _find(avl* nod, int x)
{
    if(nod == NULL || nod->val == x) return nod;

    if(nod->val < x) nod = _find(nod->r, x);
    else nod = _find(nod->l, x);
}
int main()
{
    fin>>t;
    root = new avl();

    while(t--)
    {
        fin>>op>>x;
        if(op==1) root = _insert(root, x);
        else if(op==2) root = _delete(root, x);
        else
        {
            avl* aux = _find(root,x);
            if(aux==NULL) fout<<"0\n";
            else fout<<"1\n";
        }
    }
    return 0;
}