#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_set>
#include <ctime>
#include <cstdlib>
#include <fstream>
using namespace std;
#define ll long long int
#define pb push_back
ifstream in ("hashuri.in");
ofstream out("hashuri.out");
///////////////////////////////
///////////
///////////         Hashuri
///////////
//////////////////////////////
const int M  =1;//195931;
const float A = 0.6180339887;
vector<int> v[M];
struct Node
{
    Node* next;
    int val;
    Node(int x):next(nullptr),val(x){};
};
Node* Hash[M],*p;
int H(int k );
void addMy(int x)
{
    int hx = H(x);
    p = Hash[hx];
    if(p->next == nullptr)
    {
        p->next = new Node(x);
        return;
    }
    p = p->next;
    while( p->val != x && p->next!= nullptr)
        p = p->next;
    if(p->val == x)
        return;
    else
        p->next = new Node(x);
}
void removeMy(int x)
{
    int hx = H(x);
    p = Hash[hx];
    if(p->next == nullptr)
        return;
    while( p->next != nullptr && p->next->val != x )
        p = p->next;
    if(p->next)
        p->next = p->next->next;
}
int findMy(int x)
{
    int hx = H(x);
    p =  Hash[hx]->next;
    while(p != nullptr && p->val !=x)
        p = p->next;
    return (p != nullptr)?1:0;
}
//--------------------------------
const int maxByte = ( 1 << 8 )-1;
const int byteNr = sizeof(int);
int getRandom()
{
    return rand()%M;
}
int getIthByte(int &n,int &i)
{
    return  ( n >> ( i * 8) ) & maxByte;
}
int getSum(int &x)
{
    int hx = 0;
    for(int i = 0 ; i < byteNr; i++)
        hx += getRandom() * getIthByte(x,i);
    return hx % M;
}
int H(int k )
{

    return getSum(k);                                 //dispersie universala
    //return trunc(M*fmod(k*A,1));                    //metoda inmultirii 100pct
    //return k % M;                                   //metoda diviziunii 100pct
}

void add(int &e)//adaugam elementul in multime
{
    int hx = H(e);
    if ( find(v[ hx ].begin(),v[hx].end(),e) != v[ hx].end())
        return;
    v[ hx ].pb(e);
}
void erase(int &e)//stergem elementul din multime
{
    int hx = H(e);
    if (find(v[ hx  ].begin(),v[hx ].end(),e) != v[ hx ].end())
        v[ hx ].erase(find(v[ hx  ].begin(),v[hx ].end(),e));
}
int find(int &e)//returnam 1 daca este in multime sau 0 altfel
{
    int hx = H(e);
    if (find(v[ hx  ].begin(),v[hx ].end(),e) !=v[hx ].end())
        return 1;
    return 0;
}
///////////////////////////////
///////////
///////////         Arbori binari de cautari echilibirati log(n) -pe operatie 70pct
///////////
//////////////////////////////
unordered_set<int> tree;
void addTree(int x)
{
    tree.insert(x);
}
void removeTree(int x)
{
    tree.erase(x);
}
int isInTree(int x)
{
    return (tree.find(x) !=tree.end())?1:0;
}
const int m = 1000003;
const int gol = 2000000003;
int Ve[m];
int h1(int k)
{
    return k % m;
}
int h2(int k)
{
    return 1+ k %(m-1);
}
int h(int k ,int i)
{
    return (h1(k) + i*h2(k) )%m;
}
void openAadd(int x)
{
    int i = 0,pos= h(x,i);
    while(Ve[pos]!=x && i!=m+1)
    {
        if(Ve[pos] == gol)
        {
            Ve[pos] = x;
            return;
        }
        i++;
        pos = h(x,i);
    }
}
void openAdel(int x)
{
    int i = 0,pos= h(x,i);
    while(Ve[pos]!=gol && i!=m+1)
    {
        if(Ve[pos] == x)
        {
            Ve[pos] = gol;
            return;
        }
        i++;
        pos = h(x,i);
    }
}
int openAsearch(int x)
{
    int i = 0,pos= h(x,i);
    while(Ve[pos]!=gol&& i!=m+1)
    {
        if(Ve[pos] == x)
            return 1;
        i++;
        pos = h(x,i);
    }
    return 0;
}
int main()
{
    //for(int i = 0 ; i < M ;i++)
      //  Hash[i] = new Node(0);
    for(int i = 0 ;  i< m ; i ++)
        Ve[i] = gol;
    srand (time(NULL));
    int n,x,op;
    in >> n;
    for(int i = 0 ; i < n ; i++)
    {
        in >> op >> x;
        switch(op)
        {
            case 1:
                openAadd(x);
                //addMy(x);
                //add(x);
                //addTree(x);
             break;
            case 2:
                openAdel(x);
                //removeMy(x);
                //erase(x);
                //removeTree(x);
            break;
            case 3:
                out<<openAsearch(x)<<'\n';
                //out<<findMy(x)<<'\n';
                //out<<find(x)<<'\n' ;
                //out<<isInTree(x)<<'\n';
            break;
        }
    }
    return 0;
}