using namespace std;

#ifndef HASH_H
#define HASH_H

#include <vector>
#include <iostream>
#include <string>
#include <typeinfo>

#define EZY 666013

template <class T, class C>

class Hash {
public:
	Hash();
	~Hash();
	
	void Insert(T key, C val);
	void Delete(T key);
	bool Contains(T key);
	C operator[](T key);
private:
	int HashT(T t);
	std::vector<std::vector<std::pair<T, C> > >  _buckets;
};

template <class T, class C> Hash<T, C>::Hash() {
	for (int i = 0; i < EZY; ++i) {
		std::vector<std::pair<T, C> > _bucket;
		_buckets.push_back(_bucket);
	}
}

template <class T, class C> Hash<T, C>::~Hash() {
	for (int i = 0; i < EZY; ++i) _buckets[i].clear();
	_buckets.clear();
}

template <class T, class C> int Hash<T, C>::HashT (T t ) {
	T* pt = &t;
    char* p=(char*)pt;
    unsigned int r = 0;
 
    for (char* pc = p; pc != p + sizeof(T); pc += sizeof(char)) {
        r = (r * 10 + int(*pc)) % EZY;
    }
 
	return r;
}

template <class T, class C> void Hash<T, C>::Insert (T key, C val ) {
	int _key = HashT(key);
	int i = 0;
	
	while (i < _buckets[_key].size()) {
		if (_buckets[_key][i].first == key) return;
		++i;
	}
	
	_buckets[_key].push_back(std::make_pair(key, val));
}

template <class T, class C> void Hash<T, C>::Delete (T key ) {
	int _key = HashT(key);
	int i = 0;
	
	while (i < _buckets[_key].size()) {
		if (_buckets[_key][i].first == key) {
			_buckets[_key].erase(_buckets[_key].begin() + i);
			return;
		}
		++i;
	}
}

template <class T, class C> bool Hash<T, C>::Contains (T key ) {
	int _key = HashT(key);
	int i = 0;
	
	while (i < _buckets[_key].size()) {
		if (_buckets[_key][i].first == key) return true;
		++i;
	}
	return false;
}

template <class T, class C> C Hash<T, C>::operator[] (T key ) {
	int _key = HashT(key);
	int i = 0;
	
	while (i < _buckets[_key].size()) {
		if (_buckets[_key][i].first == key) return _buckets[_key][i].second;
		++i;
	}
	return NULL;
}

#include <fstream>
#include <iostream>
	
int main () {
	ifstream fin("hashuri.in");
    ofstream fout("hashuri.out");

	Hash<int, int> hash;

	int N; fin >> N;
	for (int i = 0; i < N; ++i) {
		int op, nr; fin >> op >> nr;
		if (op == 1) hash.Insert(nr, 0);
		else if (op == 2) hash.Delete(nr);
		else if (op == 3) fout << hash.Contains(nr) << "\n";
	}

	fin.close();
	fout.close();
}