#include <bits/stdc++.h>

using namespace std;

random_device myDevice;
mt19937 generator (myDevice());
uniform_int_distribution<> randomDistribution (0, 1000000000);

class Treaps {
public:
    Treaps () {
        NILL = new nodes (0, -1, nullptr, nullptr);
        for (int index = 0; index < MOD; ++index) {
            root[index] = NILL;
        }
    }

    bool insertValue (int value) {
        int currentRoot = value % MOD;
        if (findValue(root[currentRoot], value)) return false;
        insertValue(root[currentRoot], value);
        return true;
    }

    bool eraseValue (int value) {
        int currentRoot = value % MOD;
        if (!findValue(root[currentRoot], value)) return false;
        eraseValue(root[currentRoot], value);
        return true;
    }

    bool findValue (int value) {
        int currentRoot = value % MOD;
        return findValue(root[currentRoot], value);
    }

private:
    const int MOD = 666013;
    struct nodes {
        int value, priority;
        nodes *left, *right;
        nodes (int value, int priority, nodes *left, nodes *right) {
            this->value = value;
            this->priority = priority;
            this->left = left;
            this->right = right;
        }
    } *root[666013], *NILL;

    int randomGenerator () {
        return randomDistribution (generator);
    }

    void leftRotate (nodes *& node) {
        nodes *aux = node->left;
        node->left = aux->right;
        aux->right = node;
        node = aux;
    }

    void rightRotate (nodes *& node) {
        nodes *aux = node->right;
        node->right = aux->left;
        aux->left = node;
        node = aux;
    }

    void balance (nodes *& node) {
        if (node == NILL) return ;
        if (node->left->priority > node->priority) {
            leftRotate(node);
        }
        if (node->right->priority > node->priority) {
            rightRotate(node);
        }
    }

    bool findValue (nodes *& node, int value) {
        if (node == NILL) return false;
        if (node->value == value) {
            return true;
        }
        if (node->value < value) {
            return findValue(node->right, value);
        }
        return findValue(node->left, value);
    }

    void insertValue (nodes *& node, int value) {
        if (node == NILL) {
            node = new nodes (value, randomGenerator(), NILL, NILL);
            return ;
        }
        if (node->value < value) {
            insertValue(node->right, value);
        }
        else {
            insertValue(node->left, value);
        }
        balance(node);
    }

    void eraseValue (nodes *& node, int value) {
        if (node->value < value) {
            eraseValue(node->right, value);
        }
        else if (node->value > value) {
            eraseValue(node->left, value);
        }
        else {
            if (node->left == NILL and node->right == NILL) {
                delete node;
                node = NILL;
                return ;
            }
            if (node->left->priority > node->right->priority) {
                leftRotate(node);
                eraseValue(node->right, value);
            }
            else {
                rightRotate(node);
                eraseValue(node->left, value);
            }
        }
    }
};

int main() {
    ifstream fin ("hashuri.in");
    ofstream fout ("hashuri.out");
    Treaps *solver = new Treaps();
    int queries;
    fin >> queries;
    for (int index = 0; index < queries; ++index) {
        int type, value;
        fin >> type >> value;
        if (type == 1) {
            solver->insertValue(value);
        }
        if (type == 2) {
            solver->eraseValue(value);
        }
        if (type == 3) {
            fout << solver->findValue(value) << '\n';
        }
    }
}