#include <iostream>
#include <fstream>
#include <cstdlib>
#include <time.h>
#include <string.h>
using namespace std;




class hash
{
public:
    int *hash1,*hash2;
    int prim;
    char *filein,*fileout;
    int a,b;
    int size;


    virtual int funct1(int) ;
    virtual int funct2(int) ;
    virtual int adauga(int) ;
    virtual int sterge(int) ;
    virtual int cautare(int) ;
    virtual void rehash(int) ;
    virtual void randomiz() ;
    virtual void aloca() ;
    virtual void reset();
    virtual void rezolvare() ;


};

class Cuckoohash: public hash
{
int n;
public:

Cuckoohash(char *in,char *out)
{
    aloca();
    prim=20983;
    filein=new char(strlen(in));
    fileout=new char(strlen(out));
    strcpy(filein,in);
    strcpy(fileout,out);
}
void rezolvare()
{
    srand(time(NULL));
    randomiz();
    reset();
    ifstream f(filein);
    ofstream g(fileout);

    int n,x,op;
    f>>n;
    for(int i=1;i<=n;i++)
    {
        f>>op>>x;
        if((op==1)&&(adauga(x)==0))rehash(i);
        if(op==2)   if(cautare(x)==1)sterge(x);
        if(op==3)
                    {
                        if(cautare(x)==1)
                            g<<1<<"\n";
                        else g<<0<<"\n";
                    }
    }
}
int funct1(int x)
    {
    int c;
    c=(((long long) x*(long long)(a%10)+(long long)x%b)+(long long)x*5)%size;
    return c;
    }

int funct2(int x)
    {
    int c;
    c=(((long long)x*((long long)(a%10))%prim)+(long long)x*(long long)(a%10))%size;
    return c;
    }

    int adauga(int x)
    {
        if(cautare(x)==1)return 0;
        int k=0,aux;
        while(k<30)
        {
            if(hash1[funct1(x)]==0)
            {
                hash1[funct1(x)]=x;
                return 1;
            }
                else
                    if(hash2[funct2(x)]==0)
                    {
                        hash2[funct2(x)]=x;
                        return 1;
                    }
                            else
                            {
                                k++;
                                if(k%2==1)
                                {
                                    aux=hash1[funct1(x)];
                                    hash1[funct1(x)]=x;
                                    x=aux;
                                }
                                            else
                                                    {
                                                            aux=hash2[funct2(x)];
                                                            hash2[funct2(x)]=x;
                                                            x=aux;
                                                    }

                            }
        }
        return 0;
    }
    int sterge(int x)
    {
        if(hash1[funct1(x)]==x)
        {
            hash1[funct1(x)]==0;
            return 1;
        }
        else
        if(hash2[funct2(x)]==x)
        {
            hash2[funct2(x)]==0;
            return 1;
        }
        else return 0;
    }


    int cautare(int x)
    {
        if(hash1[funct1(x)]==x)return 1;
        if(hash2[funct2(x)]==x)return 1;
        return 0;
    }
    void rehash(int j)
    {
        reset();
        randomiz();
        ifstream f(filein);

        int op,x;
        f>>op;
        for(int i=1;i<=n;i++)
        {
            f>>op>>x;
            if((op==1)&&(adauga(x)==0))rehash(i);
                if((op==2)&&(cautare(x)==1))sterge(x);

        }
    }
    void randomiz()
    {
        srand(time(NULL));
        a=rand()%100;
        b=rand()%99;

    }
    void aloca()
    {
        size=1000000;
        hash1=(int*)calloc(size,sizeof(int));
        hash2=(int*)calloc(size,sizeof(int));
    }
    void reset()
    {
        for(int i=1;i<size;i++)
        {
            hash1[i]=0;
            hash2[i]=0;
        }
    }



};








int main()
{
Cuckoohash cuckoo("hashuri.in","hashuri.out");
hash *pointer1=&cuckoo;
pointer1->rezolvare();
return 0;

}