#include <fstream>
using namespace std;


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

struct node
{
	int inf;
	unsigned char inaltime;    // simplifica niste operatii
	node* left;
	node* right;
	node(int k) { inf = k; left = right = 0; inaltime = 1; }
};

unsigned char inaltime(node* p) // necesara pentru pointeri nuli
{
	return p ? p->inaltime : 0;
}

int bfactor(node* p)   // poate returna -2,-1,0,1,2
{
	return inaltime(p->right) - inaltime(p->left);
}

void calculinaltime(node* p)    //calculul inaltimii
{
	unsigned char hl = inaltime(p->left);
	unsigned char hr = inaltime(p->right);
	p->inaltime = (hl>hr ? hl : hr) + 1;
}

node* rotdr(node* p)
{
	node* q = p->left;
	p->left = q->right;
	q->right = p;
	calculinaltime(p);
	calculinaltime(q);
	return q;
}

node* rotst(node* q)
{
	node* p = q->right;
	q->right = p->left;
	p->left = q;
	calculinaltime(q);
	calculinaltime(p);
	return p;
}

node* balance(node* p)  // rezolva cazurile de inbalanta: bfactor=-2 sau bfactor=2
{
	calculinaltime(p);
	if (bfactor(p) == 2)
	{
		if (bfactor(p->right) < 0)
			p->right = rotdr(p->right);
		return rotst(p);
	}
	if (bfactor(p) == -2)
	{
		if (bfactor(p->left) > 0)
			p->left = rotst(p->left);
		return rotdr(p);
	}
	return p;
}

node* ins(node* p, int k)
{
	if (!p) return new node(k);
	if (k<p->inf)
		p->left = ins(p->left, k);
	else
		if (k >= p->inf)
		{
			p->right = ins(p->right, k);
		}
		else
		{
			return p; // elementul exista deja
		}
	return balance(p);
}

node* gasmin(node* p)
{
	return p->left ? gasmin(p->left) : p;
}

node* stergemin(node* p)
{
	if (p->left == 0)
		return p->right;
	p->left = stergemin(p->left);
	return balance(p);
}

node* sterge(node* p, int k)
{
	if (!p) return 0;
	if (k < p->inf)
		p->left = sterge(p->left, k);
	else if (k > p->inf)
		p->right = sterge(p->right, k);
	else
	{
		node* q = p->left;
		node* r = p->right;
		delete p;
		if (!r) return q;		// min=tatal lui q
		node* min = gasmin(r);
		min->right = stergemin(r);
		min->left = q;
		return balance(min);
	}
	return balance(p);
}

bool find(node*p, int x)
{
	if (!p) return 0;
	if (x< p->inf)
		return (find(p->left, x));
	if (x>p->inf)
		return (find(p->right, x));
	if (p->inf == x)
	{
		return 1;
	}
}

void tip(node *p) // tiparire in inordine (pt sortare) 
{
	if (p->left)
		tip(p->left);
	fout << p->inf << ' ';
	if (p->right)


		tip(p->right);


}

int main()
{
	int n;
	fin >> n;
	node* p;
	for (int i = 1; i <= n; i++)
	{
		int op;
		fin >> op;
		int x;
		fin >> x;
		if (op == 1)
		{
			ins(p, x);
		}
		if (op == 2)
		{
			sterge(p, x);
		}
		if (op == 3)
		{
			fout << find(p, x) << '\n';
		}
	}
}