#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#define prim 1000000009

class Cuckoo
{
    private:
        int a1, a2, b1, b2;
        int size, *H1, *H2;
         
    public:
        Cuckoo(int SIZE)
        {
            srand(time(NULL));
            size = SIZE;
            H1 = (int*)calloc(size, sizeof(int));
            H2 = (int*)calloc(size, sizeof(int));
            a1=rand()%size; a2=rand()%size;
            b1=rand()%size; b2=rand()%size;
        }           
         
        int hash1(int &x)
        {
            return (((long long)a1*x + b1)%prim)%size;
        }
         
        int hash2(int &x)
        {
            return (((long long)a2*x + b2)%prim)%size;
        }
        
		int hash(int x)
        {
            if (find(x))
                return -1;
            int aux, val1, val2, i, old=x;
            bool inPlace = 0;
            for (i=0; !inPlace; ++i)
            {
                if (i && x==old)
                    return 0;
                val1=hash1(x); val2=hash2(x);
                if (H1[val1] == 0)
                {
                    H1[val1] = x;
                    inPlace = 1;
                }
                else if (H2[val2] == 0)
                {
                    H2[val2] = x;
                    inPlace = 1;
                }
                else
                {
                    aux = H1[val1];
                    H1[val1]=x; x=aux;
                    val2 = hash2(x);
                    if (H2[val2] == 0)
                    {
                        H2[val2] = x;
                        inPlace = 1;
                    }
                    else
                    {
                        aux = H2[val2];
                        H2[val2]=x; x=aux;
                    }
                }
            }
            return 1;
        }
		
		int insert(int x)
		{
			int canInsert = hash(x);
			if (canInsert == -1) return 0;	//x e deja in hash
			if (canInsert == 1) return 1;	//adaugat cu succes
			if (!canInsert)					//ciclu => rehash
			{
				int *H1_temp = (int*)malloc(size*sizeof(int));
				memcpy(H1_temp, H1, size);
				int *H2_temp = (int*)malloc(size*sizeof(int));
				memcpy(H2_temp, H2, size);
				
				while (!canInsert)
				{
					a1=rand()%size; a2=rand()%size;
					b1=rand()%size; b2=rand()%size;
					free(H1); free(H2);
					H1 = (int*)calloc(size, sizeof(int));
					H2 = (int*)calloc(size, sizeof(int));
					
					canInsert = 1;
					for (int i=0; i<size && canInsert==1; ++i)
					{
						if (H1_temp[i])
							canInsert = hash(H1_temp[i]);
						if (canInsert==1 && H2_temp[i])
							canInsert = hash(H2_temp[i]);
					}
				}
				
				memcpy(H1, H1_temp, size);
				free(H1_temp);
				memcpy(H2, H2_temp, size);
				free(H2_temp);
			}
			return 2;	//inserat cu succes, dupa rehash
		}
				
		
        bool find(int &x)
        {
            return (H1[hash1(x)]==x || H2[hash2(x)]==x);
        }
         
        bool erase(int &x)
        {
            if (!find(x)) return 0;
            if (H1[hash1(x)] == x)
                H1[hash1(x)] = 0;
            else H2[hash2(x)] = 0;
            return 1;
        }
		
		const Cuckoo &operator +(int &val)
		{
			this->insert(val);
			return *this;
		}
		
		const Cuckoo &operator -(int &val)
		{
			this->erase(val);
			return *this;
		}
		
		const Cuckoo &operator /(int &val)
		{
			printf("%d\n", this->find(val));
			return *this;
		}
};

int main()
{
    freopen("hashuri.in", "r", stdin);
    freopen("hashuri.out", "w", stdout);
    int n, c, x, i;
    Cuckoo H(1000000);
    scanf("%d", &n);
    for (i=0; i<n; ++i)
    {
        scanf("%d%d", &c, &x);
        switch (c)
        {
            case 1: H+x; break;
            case 2: H-x; break;
            case 3: H/x; break;
        }
    }
    return 0;
}