#include<fstream>
#include<algorithm>
#include<cmath>
#include<ctime>
using namespace std;

#define ll long long

class cockooHash
{
    int *h1, *h2, table_size, prime_nr, max_steps;
    int a1, a2, b1, b2;
    bool *viz1, *viz2;

    void generate(int &a,int &b)
    {
        a = rand() % this->table_size;
        b = rand() % this->table_size;
    }

    int hash1(int val)
    {
        return ( ( ( (ll)this->a1 * (ll)val + (ll)this->b1) % (ll)this->prime_nr ) % (ll)this->table_size );
    }

    int hash2(int val)
    {
        return ( ( ( (ll)this->a2 * (ll)val + (ll)this->b2) % (ll)this->prime_nr ) % (ll)this->table_size );
    }

    public:

    cockooHash(int dim)
    {
        this->table_size = dim;
        this->prime_nr = 1000000009;
        this->max_steps = (int)log2(this->table_size);

        this->h1 = new int[this->table_size];
        this->h2 = new int[this->table_size];

        fill(this->h1, this->h1+this->table_size, 0);
        fill(this->h2, this->h2+this->table_size, 0);

        this->viz1 = new bool[this->table_size];
        this->viz2 = new bool[this->table_size];
        fill(this->viz1, this->viz1+this->table_size, false);
        fill(this->viz2, this->viz2+this->table_size, false);


        generate(a1, b1);
        generate(a2, b2);
    }

    bool find(int val)
    {
        int k1, k2;

        k1 = hash1(val);
        k2 = hash2(val);

        if(this->h1[k1] == val && this->viz1[k1] == true)
            return true;
        if(this->h2[k2] == val && this->viz2[k2] == true)
            return true;

        return false;
    }

    bool erase(int val)
    {
        int k1 = hash1(val);
        int k2 = hash2(val);

        if(this->h1[k1] == val && this->viz1[k1] == true)
        {
            this->h1[k1] = 0;
            this->viz1[k1] = false;
            return true;
        }
        if(this->h2[k2] == val && this->viz2[k2] == true)
        {
            this->h2[k2] = 0;
            this->viz2[k2] = false;
            return true;
        }

        return false;
    }

    bool insert(int val)
    {
        int x = val;
        int k1 = hash1(x);
        int k2 = hash2(x);

        if(this->h1[k1] == 0 && this->viz1[k1] == false)
        {
            this->h1[k1] = x;
            this->viz1[k1] = true;
            return true;
        }

        for(int i = 0; i<this->max_steps; i+=2)
        {
            if(this->h2[k2] == 0 && this->viz2[k2] == false)
            {
                this->h2[k2] = x;
                this->viz2[k2] = true;
                return true;
            }

            swap(x, this->h2[k2]);
            k1 = hash1(x);
            k2 = hash2(x);

            if(this->h1[k1] == 0 && this->viz1[k1] == false)
            {
                this->h1[k1] = x;
                this->viz1[k1] = true;
                return true;
            }

            swap(x, this->h1[k1]);
            k1 = hash1(x);
            k2 = hash2(x);
        }

        return false;
    }
};

int main()
{
    cockooHash *hash;
    hash=new cockooHash(1000000);
    ifstream f("hashuri.in");
    ofstream g("hashuri.out");

    int n,op,x;

    f>>n;

    for (int i=1;i<=n;i++)
    {
        f>>op>>x;
        if (op == 1) hash->insert(x);
        else if (op == 2) hash->erase(x);
        else g<<hash->find(x)<<"\n";

    }

    f.close();
    g.close();

    delete hash;
    hash = 0;

    return 0;

}