/*
#define max(a, b) ( (a) > (b) ? (a) : (b) )
#define geth(n) ( n->h = 1 + max(n->l->h, n->r->h) )

struct node
{
    int key;
    int h; /// height
    node *l, *r; /// left, right
} *Root, *NIL;

void Initize_AVL()
{
    NIL = new node;
    NIL->key = NIL->h = 0,
        NIL->l = NIL->r = NULL;
    Root = NIL;
}

node* rotleft(node* n)
{
    node *t = n->r;

    n->r = t->l, t->l = n;
                      geth(n), geth(t);
    return t;
}

node* rotright(node* n)
{
    node* t = n->l;

    n->l = t->r, t->r = n,
                      geth(n), geth(t);
    return t;
}

node* balance(node* n)
{
    geth(n);

    if( n->l->h > n->r->h + 1 )
    {
        if( n->l->r->h > n->l->l->h ) /// rotatie dubla dreapta
            n->l = rotleft( n->l );

        n = rotright(n);
    }

    if( n->r->h > n->l->h + 1 )
    {
        if( n->r->l->h > n->r->r->h ) /// rotatie dubla stanga
            n->r = rotright( n->r );

        n = rotleft(n);
    }

    return n;
}

node* insert_node(node *n, int key)
{
    if( n == NIL )
    {
        n = new node;
        n->key = key, n->h = 1,
                 n->l = n->r = NIL;
        return n;
    }
    else
    {
        if( n->key == key )
            return n;
        else
        {
            if( n->key > key )
               n->l = insert_node(n->l, key);
            else
               n->r = insert_node(n->r, key);
        }
    }
    return balance(n);
}

node* delete_node(node* n, int key)
{
    node* t;

    if( n == NIL )
        return n;

    if( n->key == key )
    {
            if( n->l == NIL || n->r == NIL )
            {
                t = ( n->l != NIL )? n->l : n->r;
                delete n;
                return t;
            }
            else
            {
                for(t = n->r ; t->l != NIL; t = t->l);
                    n->key = t->key;
                n->r = delete_node(n->r, n->key);

                return balance(n);
            }
    }
    else
    {
        if( n->key > key )
            n->l = delete_node(n->l, key);
        else
            n->r = delete_node(n->r, key);
    }
    return balance(n);
}

bool search_node(node *n, int key)
{
    if( n == NIL )  return false;
    if( n->key == key )  return true;
    else
    {
        if( n->key > key )
            return search_node(n->l, key);
        else
            return search_node(n->r, key);
    }
}
*/

#include <iostream>
#include <fstream>
#include <list>
using namespace std;
ifstream f("hashuri.in");
ofstream g("hashuri.out");
#define P1 1300111
#define P2 1300097
list <int> H1[P1+3],H2[P2+3];
int N,op,x;

void InserareHash(int key)
{
    int ad1,ad2;
    ad1 = key % P1;
    ad2 = key % P2;

    if( H1[ad1].size() < H2[ad2].size() )
        H1[ad1].push_back(key);
    else
        H2[ad2].push_back(key);
}

void StergereHash(int key)
{
    int ad1,ad2;
    ad1 = key % P1;
    ad2 = key % P2;

    for( list<int>::iterator it = H1[ad1].begin() ; it != H1[ad1].end() ; it++)
         if( *it == key )
         {
             H1[ad1].erase(it);
             return;
         }
    for( list<int>::iterator it = H2[ad2].begin() ; it != H2[ad2].end() ; it++)
         if( *it == key )
         {
             H2[ad2].erase(it);
             return;
         }
}

bool CautareHash(int key)
{
    int ad1,ad2;
    ad1 = key % P1;
    ad2 = key % P2;

    for( list<int>::iterator it = H1[ad1].begin() ; it != H1[ad1].end() ; it++)
         if( *it == key )
             return 1;
    for( list<int>::iterator it = H2[ad2].begin() ; it != H2[ad2].end() ; it++)
         if( *it == key )
             return 1;
    return 0;
}

int main()
{
    f>>N;
    for(int i = 1 ; i <= N ; i++)
    {
        f>>op>>x;

        switch(op)
        {
           case 1 : InserareHash(x); break;
           case 2 : StergereHash(x); break;
           case 3 : g<<CautareHash(x)<<'\n'; break;
        }
    }
    return 0;
}