#include <fstream.h>

int N;
char S[32];
ifstream fin("trie.in");
ofstream fout("trie.out");

struct Node {
    int total;
    int stopped;
    Node * nodes[26];

    // constructor

    Node() {
        total = 0;
        stopped = 0;
        for (int i = 0; i < 26; ++i) {
            nodes[i] = 0;
        }
    }

}
root;

// add a node

void add(int index, int length, Node* node) {

    // add to total
    ++node->total;

    // is it non final?
    if (index < length) {

        // get index
        int e = S[index + 1] - 'a';

        // child does not exist?
        if (node->nodes[e] == 0) {

            // create child
            node->nodes[e] = new Node();

        }

        // add to child
        add(index + 1, length, node->nodes[e]);

    } else {

        // add to stopped
        node->stopped++;

    }

}

// remove a node

void remove(int index, int length, Node* node) {

    // subtract from total
    --node->total;

    // is it non final?
    if (index < length) {

        // get index
        int e = S[index + 1] - 'a';

        // remove from child
        remove(index + 1, length, node->nodes[e]);

        // is child not worth?
        if (node->nodes[e]->total <= 0) {

            // delete the child
            delete node->nodes[e];

            // set null
            node->nodes[e] = 0;

        }

    } else {

        // subtract from stopped
        node->stopped--;

    }

}

// write a node

int write(int index, int length, Node* node) {

    // is it non final?
    if (index < length) {

        // get index
        int e = S[index + 1] - 'a';

        // does child exist?
        if (node->nodes[e] > 0) {

            // return from child
            return write(index + 1, length, node->nodes[e]);

        } else {

            // return just from here
            return 0;

        }

        // return from child
        return write(index + 1, length, node->nodes[e]);

    } else {

        // return from here
        return node->stopped;

    }

}

// prefix a node

int prefix(int index, int length, Node* node) {

    // is it non final?
    if (index < length) {

        // get index
        int e = S[index + 1] - 'a';

        // does child exist?
        if (node->nodes[e] > 0) {

            // return from child
            return 1 + prefix(index + 1, length, node->nodes[e]);

        } else {

            // return just from here
            return 0;

        }

    } else {

        // return from here
        return 0;

    }

}

int main() {

    while (fin >> N) {
        fin >> S;
        int L = strlen(S) - 1;
        switch (N) {
            case 0:
                add(-1, L, &root);
                break;
            case 1:
                remove(-1, L, &root);
                break;
            case 2:
                fout << write(-1, L, &root) << '\n';
                break;
            case 3:
                fout << prefix(-1, L, &root) << '\n';
                break;
        }
    }

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