#define MT_INIT_CU_VALOAREA 0
#define m 134999   // nr prim
#define MAXNR 2000000005

#include <stdio.h>
//#include <conio.h>
#include <stdlib.h>

/*
** ALGORITMUL MERSENNE-TWISTER
*/
#define N 624
#define M 397
#define MATRIX_A 0x9908b0dfUL   /* constant vector a */
#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
#define LOWER_MASK 0x7fffffffUL /* least significant r bits */

static unsigned long mt[N]; /* the array for the state vector  */
static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
void init_genrand(unsigned long s)
{
    mt[0]= s & 0xffffffffUL;
    for (mti=1; mti<N; mti++) {
        mt[mti] =
	    (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
        mt[mti] &= 0xffffffffUL;
    }
}
unsigned long genrand_int32(void)
{
    unsigned long y;
    static unsigned long mag01[2]={0x0UL, MATRIX_A};
    if (mti >= N) {
        int kk;
        if (mti == N+1)
            init_genrand(5489UL);

        for (kk=0;kk<N-M;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        for (;kk<N-1;kk++) {
            y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
            mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
        }
        y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
        mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];

        mti = 0;
    }
    y = mt[mti++];
    y ^= (y >> 11);
    y ^= (y << 7) & 0x9d2c5680UL;
    y ^= (y << 15) & 0xefc60000UL;
    y ^= (y >> 18);
    return y;
}
double genrand_real2(void)
{
    return genrand_int32()*(1.0/4294967296.0);
}
/* 
** END: MERSENNE-TWISTER
*/

/*
** FUNCTIA HASH
** sursa: UPT, AN I, CTI, P&S Proiectul 2 - 2012
*/
int j,r,*x,y;

void init_mersenne_dupa_secunde() {
     time_t secunde;
     secunde=time(NULL);
     init_genrand(secunde);
}

int cel_mai_semnificativ_bit(unsigned long m1)
{
    unsigned int masca=1;
    int i,j=0;
    for (i=31;i>=0;i--)
        if (m1&(masca<<i)) return i+1;
}
int calculare_r(int j){
    int r;
    r=cel_mai_semnificativ_bit(MAXNR)/(j);
    if ((8*(sizeof(unsigned long))%j)==0) return r;
       else return r+1;
}

int* cioparteste(unsigned long x,int j,int r) {
     unsigned long masca=0;
     int i;
     for (i=0; i<j; i++) {
         masca = (masca << 1) | 1;
     }
     int *k;
     k = (int *)malloc( r * sizeof(int) );
     for (i=0; i<r; i++) {
         k[i] = x & masca;
         x = x >> j;
     }
     return k;
}

unsigned long nr_aleator_din_Zm()
{
 float rand;
 rand=genrand_real2();
 return(floor(rand*m));
}

int valoare_hash(int *x,int *k,int y,int r){
  unsigned long i;   
  int j;
  i=0;
  for(j=0;j<r;j++) {
      i += k[j]*x[j];
  }    
  i+=y;
  return i % m;     
}

int hashvalue( unsigned long z ) {
    int i, *kk;
    kk = cioparteste(z,j,r);
    i= valoare_hash(x,kk,y,r);
    free(kk);
    return i;
}

void init_hashfunc() {
    int i;
    if (MT_INIT_CU_VALOAREA)
	   init_genrand(MT_INIT_CU_VALOAREA);
      else
       init_mersenne_dupa_secunde();
    j = cel_mai_semnificativ_bit( m );
	r = calculare_r(j);
	 
	x=(int *)malloc(r*sizeof(int));
	
	y=nr_aleator_din_Zm(m); 
    for(i=0;i<r;i++) {
          x[i]=nr_aleator_din_Zm(m);  
    }
}
/*
** END FCTIA HASH
*/

/*
** LISTE INLANTUITE
*/

typedef struct LI {
       struct LI *urm;
       unsigned long x;
} li;

void LI_ad( li *c, unsigned long x ) {
     li *n;
     n = (li *)malloc( sizeof( li ) );
     n->urm = c->urm;
     n->x = x;
     c->urm = n;
}

li *LI_srch( li *c, unsigned long x ) {
     li *p;
     p = c->urm;
     while (p != NULL) {
           if ( p->x == x ) {
              return c;
           }
           c = p;
           p = p->urm;
     }
     return NULL;
}

void LI_del( li *c, unsigned long x ) {
     li *p;
     p = LI_srch( c, x );
     if ( p != NULL ) {
          c = p->urm;
          p->urm = p->urm->urm;
          free(c);
     }
}

int hash_simplu( unsigned int z ) {
  return z % m;
}

li *ht;
 
int main(void) {
    init_hashfunc();
    
    ht = (li *)calloc( m,sizeof(li) );
    
    FILE *fi,*fo;
    fi = fopen("hashuri.in","r");
    fo = fopen("hashuri.out","w");
    int op, no,i,idx;
    unsigned long x;
    fscanf(fi, "%d", &no);
    
    for (i=0;i<no;i++) {
        fscanf(fi, "%d %u", &op, &x );
        //idx = hashvalue( x );
        idx = hash_simplu( x );
        switch (op) {
               case 1:
                    if ( LI_srch( &ht[idx], x ) == NULL )
                       LI_ad( &ht[idx], x );
                    break;
               case 2:
                    LI_del( &ht[idx], x );
                    break;
               case 3:
                    fprintf(fo, "%d\n", (LI_srch( &ht[idx], x ) == NULL) ? 0 : 1 );
        }
    }
    fclose(fi);
    fclose(fo);
}