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

#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::pair<bool, std::pair<T, C> > > _buckets;
};

template <class T, class C> Hash<T, C>::Hash() {
	T t; C c;
	for (int i = 0; i < EZY; ++i) _buckets.push_back(std::make_pair(false, std::make_pair(t, c)));
}

template <class T, class C> Hash<T, C>::~Hash() {
	_buckets.clear();
}

template <class T, class C> int Hash<T, C>::HashT (T t ) {
	T* pt = &t;
    char* p=(char*)pt;
    int r = 0;

	// make modulo using the bytes of T 
    for (char* pc = p; pc != p + sizeof(T); pc += sizeof(char)) {
        r = (r * 10 + int(*pc)) % EZY;
    }
    
    // continue modulo on object's name
    std::string name = typeid(T).name();
	for (int i = 0; i < name.size(); ++i) {
		r = (r * 10 + int(name[i])) % EZY;
	}
	
    return r;
}

template <class T, class C> void Hash<T, C>::Insert (T key, C val ) {
	int _key = HashT(key);
	_buckets[_key] = std::make_pair(true, std::make_pair(key, val));
}

template <class T, class C> void Hash<T, C>::Delete (T key ) {
	int _key = HashT(key);
	_buckets[_key].first = false;
}

template <class T, class C> bool Hash<T, C>::Contains (T key ) {
	int _key = HashT(key);
	return _buckets[_key].first;
}

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

int main () {
	std::ifstream fin("hashuri.in");
	std::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();
}