//#include "stdafx.h"
#include <iostream>
#include <algorithm>

#include <cassert>
#include <cstdio>

using namespace std;

struct AVLNode {
	int value, height;
	AVLNode *left, *right;
} *root, *nil;

void updateHeight(AVLNode *node) {
	if (node == nil)
		return;
	node->height = 1 + max(node->left->height, node->right->height);
}

AVLNode *rotateRight(AVLNode *node) {
	AVLNode *ret = node->right;
	node->right = ret->left;
	ret->left = node;
	updateHeight(ret->left);
	updateHeight(ret);
	return ret;
}

AVLNode *rotateLeft(AVLNode *node) {
	AVLNode *ret = node->left;
	node->left = ret->right;
	ret->right = node;
	updateHeight(ret->right);
	updateHeight(ret);
	return ret;
}

AVLNode *balanceNode(AVLNode *node) {
	if (node->left->height > node->right->height + 1) {
		if (node->left->right->height > node->left->left->height) {
			node->left = rotateRight(node->left);
		}
		node = rotateLeft(node);
	}
	else if (node->right->height > node->left->height + 1) {
		if (node->right->left->height > node->right->right->height) {
			node->right = rotateLeft(node->right);
		}
		node = rotateRight(node);
	}
	return node;
}

AVLNode *insertValue(AVLNode *node, int value) {
	if (node == nil) {
		node = new AVLNode;
		node->value = value;
		node->left = node->right = nil;
		node->height = 1;
		return node;
	}
	if (value == node->value)
		return node;
	if (value < node->value)
		node->left = insertValue(node->left, value);
	else
		node->right = insertValue(node->right, value);
	return balanceNode(node);
}

AVLNode *deleteValue(AVLNode *node, int value) {
	if (node == nil)
		return nil;
	if (value == node->value) {
		if (node->left == nil && node->right == nil) {
			delete node;
			return nil;
		}
		if (node->left == nil) {
			AVLNode *temp = node->right;
			delete node;
			return temp;
		}
		if (node->right == nil)  {
			AVLNode *temp = node->left;
			delete node;
			return temp;
		}
		AVLNode *nextNode = node->right;
		while (nextNode->left != nil)
			nextNode = nextNode->left;
		node->value = nextNode->value;
		node->right = deleteValue(node->right, node->value);
		return balanceNode(node);
	}
	if (value < node->value)
		node->left = deleteValue(node->left, value);
	else
		node->right = deleteValue(node->right, value);
	return balanceNode(node);
}

void inorderTraversal(AVLNode *node) {
	if (node == nil)
		return;
	inorderTraversal(node->left);
	cout << node->value << ' ';
	inorderTraversal(node->right);
}

int countValue(AVLNode *node, int value) {
	if (node == nil)
		return 0;
	if (value == node->value)
		return 1;
	if (value < node->value)
		return countValue(node->left, value);
	return countValue(node->right, value);
}

bool dfsCheck(AVLNode *node) {
	if (node == nil)
		return 1;
	if (!dfsCheck(node->left))
		return 0;
	if (!dfsCheck(node->right))
		return 0;

	if (abs(node->left->height - node->right->height) > 1)
		return 0;
	updateHeight(node);
	return 1;
}


int main() {
	nil = root = new AVLNode;
	nil->left = nil->right = nil;
	nil->height = 0;

	assert(freopen("hashuri.in", "r", stdin));
	assert(freopen("hashuri.out", "w", stdout));

	int N;
	scanf("%d", &N);
	while (N--) {
		int op, x;
		scanf("%d %d", &op, &x);
		if (op == 1)
			root = insertValue(root, x);
		else if (op == 2)
			root = deleteValue(root, x);
		else
			cout << countValue(root, x) << '\n';
	}
	assert(dfsCheck(root));

	return 0;
}