#include <algorithm>
#include <fstream>

using namespace std;

struct Node {
public:
    int key, pry;
    Node *left, *right;
    Node(int _key):
        key(_key), pry(get_random()), left(NULL), right(NULL) {}
private:
    int get_random() {
        return (rand() << 16) + rand();
    }
};

pair<Node*, Node*> split(Node *node, int val) {
    if (node == NULL)
        return make_pair((Node*) NULL, (Node*) NULL);

    if (val <= node->key) {
        pair<Node*, Node*> spl = split(node->left, val);
        node->left = spl.second;
        spl.second = node;
        return spl;
    } else {
        pair<Node*, Node*> spl = split(node->right, val);
        node->right = spl.first;
        spl.first = node;
        return spl;
    }
}

Node* merge(Node *left, Node* right) {
    if (left == NULL) return right;
    if (right == NULL) return left;

    if (left->pry > right->pry) {
        left->right = merge(left->right, right);
        return left;
    } else {
        right->left = merge(left, right->left);
        return right;
    }
}

bool find(Node* node, int val) {
    if (node == NULL) return false;
    if (val < node->key) return find(node->left, val);
    else if (val > node->key) return find(node->right, val);
    return true;
}

Node *insert(Node *root, int val) {
    if (find(root, val)) return root;
    pair<Node*, Node*> spl = split(root, val);
    return merge(merge(spl.first, new Node(val)), spl.second);
}

Node *remove(Node *root, int val) {
    if (root == NULL) return NULL;
    if (root->key == val) {
        return merge(root->left, root->right);
    } else if (val < root->key) {
        root->left = remove(root->left, val);
        return root;
    } else {
        root->right = remove(root->right, val);
        return root;
    }
}

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

    int T;
    fin >> T;

    Node *root = NULL;
    while (T-- > 0) {
        int op, val;
        fin >> op >> val;
        if (op == 1) root = insert(root, val);
        else if (op == 2) root = remove(root, val);
        else fout << int(find(root, val)) << '\n';
    }

    fin.close();
    fout.close();
}