#include "iostream"
#include "string"
#include "cstdint"
#include "string"
#include "fstream"
using namespace std;

#define temp template<class t_key, class t_info>
#define types t_key, t_info

template<class t_key, class t_info>class element{
	t_key key;
	t_info info;
	element* next;
public:
	void set_key(t_key);
	void set_info(t_info);
	void set_point(element*);
	t_key get_key();
	t_info get_info();
	element* get_point();
};

template<class t_key, class t_info>class list{
private:
	element<types>* head = NULL;
	element<types>* search_by_info(t_info);
public:
	void addElement(t_key, t_info);
	void deleteEl(t_key);
	element<types>* search_by_key(t_key);
	void display();
	bool exista(t_key);
};

template<class t_key, class t_info>class Mymap{
private:
	static const int MAX = 937;
	list<types> map_element[MAX];
public:
	int hash(const t_key&);
	void push_back(t_key, t_info);
	t_info operator[](t_key);
	void erase(t_key);
	bool exista(t_key);
};

int main()
{
	ifstream hashuri_in("hashuri.in");
	ofstream hashuri_out("hashuri.out");
	Mymap<int, int> a;
	int n;
	hashuri_in >> n;
	for (int i = 0; i < n; i++)
	{
		int x, y;
		hashuri_in >> x >> y;
		if (x == 1)
		{
			a.push_back(y, 0);
		}
		if (x == 2)
		{
			a.erase(y);
		}
		if (x == 3)
		{
			if (a.exista(y))
				hashuri_out << 1 << endl;
			else
				hashuri_out << 0 << endl;
		}
	}
}

/*element*/
temp void element<types>::set_key(t_key cur)
{
	key = cur;
}
temp void element<types>::set_info(t_info cur)
{
	info = cur;
}
temp void element<types>::set_point(element* cur)
{
	next = cur;
}
temp t_key element<types>::get_key()
{
	return key;
}
temp t_info element<types>::get_info()
{
	return info;
}
temp element<types>* element<types>::get_point()
{
	return next;
}

/*list*/
temp element<types>* list<types>::search_by_key(t_key for_search)
{
	if (head == NULL)
		return head;
	element<types>* cur = head;
	while (cur)
	{
		if (cur->get_key() == for_search)
			return cur;
		cur = cur->get_point();
	}
	return cur;
}
temp element<types>* list<types>::search_by_info(t_info for_search)
{
	if (head == NULL)
		return head;
	element<types>* cur = head;
	element<types>* prev = head;
	while (cur)
	{
		if (cur->get_info() == for_search)
			return cur;
		prev = cur;
		cur = cur->get_point();
	}
	return cur;
}
temp void list<types>::addElement(t_key cur_key, t_info cur_info)
{
	if (search_by_key(cur_key))
	{
		search_by_key(cur_key)->set_info(cur_info);
		return;
	}
	element<types>* newEl = new element<types>;
	newEl->set_info(cur_info);
	newEl->set_key(cur_key);
	newEl->set_point(NULL);
	if (head == NULL)
	{
		head = newEl;
		return;
	}
	element<types> *cur = head;
	while (cur)
	{
		if (cur->get_point() == NULL)
		{
			cur->set_point(newEl);
			return;
		}
		cur = cur->get_point();
	}
}
temp void list<types>::deleteEl(t_key cur_info)
{
	element<types> *ptr = search_by_key(cur_info);
	if (ptr == head)
	{
		head = ptr->get_point();
		return;
	}
	element<types> *cur = head;
	element<types> *prev = head;
	while (cur)
	{
		if (cur == ptr)
		{
			prev->set_point(cur->get_point());
			return;
		}
		prev = cur;
		cur = cur->get_point();
	}
}
temp void list<types>::display()
{
	element<types> *list = head;
	while (list)
	{
		cout << list->get_info() << ' ';
		list = list->get_point();
	}
	cout << endl;
}
temp bool list<types>::exista(t_key cur)
{
	if (search_by_key(cur))
		return true;
	else
		return false;
}

/*map*/
temp void Mymap<types>::push_back(t_key cur_key, t_info cur_info)
{
	map_element[hash(cur_key)].addElement(cur_key, cur_info);
}
temp t_info Mymap<types>::operator[](t_key cur)
{
	return map_element[hash(cur)].search_by_key(cur)->get_info();
}
temp int Mymap<types>::hash(const t_key &key)
{
	int i = *(int*)&key;
	return i % MAX;
}
temp void Mymap<types>::erase(t_key cur)
{
	if (map_element[hash(cur)].exista(cur))
	map_element[hash(cur)].deleteEl(cur);
}
temp bool Mymap<types>::exista(t_key cur)
{
	if (map_element[hash(cur)].exista(cur))
		return true;
	return false;	
}