#include <iostream>
#include <fstream>
#include <list>
#include <vector>
#include <algorithm>
using namespace std;

typedef unsigned char byte;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned long long ulonglong;

#define NDEBUG

#ifdef NDEBUG
#define dbg	0 && (*((ostream *) 0))
#else
#define dbg clog
#endif

template<class T>
class AbstractHashTable {
	public:
		virtual void add(T value) 	= 0;
		virtual bool find(T value) 	= 0;
		virtual void erase(T value)	= 0;
};

typedef std::list<ulong> List;

namespace Global {
	const ulong hashPrime = 666013;//786433;
	List hashList[hashPrime];
}

class VectorBasedHashTable : public AbstractHashTable<ulong> {
	public:
		typedef AbstractHashTable<ulong> Base;		
		
	public:
		VectorBasedHashTable(ulong hashNumber) 
			:	hash(hashNumber) {
			hashTable = Global::hashList;
			//hashTable = new List[hashNumber];
		}
		//~VectorBasedHashTable() { delete [] hashTable; }
		
	public:
		virtual void add(ulong value) {
			// if(!find(value)) {
				// ulong position = hashNumber(value);
				// hashTable[position].push_back(value);
			// }
			insert_if_not_found(value);
		}
		
		virtual bool find(ulong value) {
			bool found = false;
			
			ulong position = hashNumber(value);
			List::iterator it = std::find(hashTable[position].begin(), hashTable[position].end(), value);
			
			if(it != hashTable[position].end())
				found = true;
			
			return found;
		}
		
		virtual void erase(ulong value) {
			ulong position = hashNumber(value);
			List::iterator it = std::find(hashTable[position].begin(), hashTable[position].end(), value);
			
			if(it != hashTable[position].end())
				hashTable[position].erase(it);
		}
	
	private:
		ulong hashNumber(ulong number) {
			return number%hash;
		}
		
		void insert_if_not_found(ulong value) {
			ulong position = hashNumber(value);
			List::iterator it = std::find(hashTable[position].begin(), hashTable[position].end(), value);
			
			if(it != hashTable[position].end()) {
				hashTable[position].push_back(value);
			}
		}
	
	private:
		List * hashTable;
		ulong hash;
		
};

int main(int argc, char * argv[]) {
	
	const char * inFile = "hashuri.in";
	const char * outFile = "hashuri.out";
	
	ifstream fin(inFile);
	ofstream fout(outFile);
	
	#ifndef NDEBUG
		if(!fin || !fout) {
			cerr << "Error opening one of \"" << inFile << "\" or \"" << outFile << "\"" << endl;
			return -1;
		}
	#endif
	
	ulong n, operation, param;
	fin >> n;
	
	VectorBasedHashTable hashTable(Global::hashPrime);
	
	for(ulong i = 0; i < n; i++) {
		fin >> operation >> param;
		switch(operation) {
			case 1:
				hashTable.add(param);
				break;
			case 2:
				hashTable.erase(param);
				break;
			case 3:
				fout << static_cast<ulong>(hashTable.find(param)) << endl;
				break;
		}
	}
	
	fout.close();
	fin.close();
	
	return 0;

}