#include <fstream>
#include <ctime>
#include <cstdlib>

using namespace std;


ifstream fin ("hashuri.in");
ofstream fout ("hashuri.out");

int N;

struct Nod{

	int key;
	int priority;

	Nod* st;
	Nod* dr;

	Nod(int key,int priority, Nod* st, Nod* dr) {

		this->st = st;
		this->dr = dr;
		this->key = key;
		this->priority = priority;
	}
};

Nod* root;
Nod* nil;//indica un nod gol, cu prioritatea cea mai mica adica 0,astfel nodul gol niciodata nu va ufca ina rbore si ramane frunza


int interogare(Nod* curent, int key) {

	if(curent == nil) return 0;

	if(curent->key == key )  return 1;

	if(curent->key > key) return interogare(curent->st, key);
	return interogare(curent->dr, key);
}

//priority(father) > prioriy(son)


void rotateToLeft(Nod* &curent) { //ridic fiul din stanga

	Nod* leftSon = curent->st;
	curent->st = leftSon->dr;

	leftSon->dr = curent;

	curent = leftSon;

}

void rotateToRight(Nod* &curent) { // ridic fiul din dreapta, ajunge in locul lui curent 

	Nod* rightSon = curent->dr;
	curent->dr = rightSon->st;
	rightSon->st = curent;

	curent = rightSon;
}

void balance(Nod* &curent) {

	if(curent->priority < curent->dr->priority)
		rotateToRight(curent);
	else if(curent->priority < curent->st->priority)
		rotateToLeft(curent);
}

void adauga(Nod* &curent,const int key, int priority) {

	if(curent == nil) {

		curent = new Nod(key, priority, nil, nil);
		return ;
	}
	
	if(key > curent->key) 
		adauga(curent->dr, key, priority);
	else 
		adauga(curent->st, key, priority);

	balance(curent);//verifica fiecare nod de pe traseu de la frunza la radacina daca respecta cei doi invarianti

}

//stergerea e toatal diferita fata de cea de laa rbori binari, ducem nodul sa fie frunza pastrand invariantii cu rotiri
void sterge(Nod* &curent, int key) {


	if(curent == nil) return ;
	//if(curent == NULL) return ;

	if(curent->key > key) 
		sterge(curent->st, key);
	else if(curent->key < key) 
		sterge(curent->dr, key);
	else {
		
		if(curent->st == nil && curent->dr == nil) {
			delete curent, curent = nil;
		} else {

			if(curent->st->priority >curent->dr->priority) {

				rotateToLeft(curent);
				sterge(curent->dr, key);
			} else {

				rotateToRight(curent);
				sterge(curent->st, key);
			}
		}
	}
	
}


int main() {

	root = nil = new Nod(0, 0, NULL, NULL);

	srand(time(NULL));

	int type; int x;

	fin >> N;


	while(N--) {

		

		fin >> type >> x;

		switch(type) {	

			case 1: adauga(root, x, rand() + 1 ); break;
			case 2:  sterge(root, x); break;
			case 3: fout << interogare( root, x) << '\n'; break;
		}
	}
	
	return 0;
}