#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#define NMAX (100000 + 3)
#define MMAX (1000000 + 3)
using namespace std;


class Node {
public:
    int count;
    int children;
    Node* next['z' - 'a'];

    Node() {
        count = children = 0;
        for (auto &edge : next) {
            edge = nullptr;
        }
    }
};

void Add(string word, Node* root) {
    Node* node = root;

    while (!word.empty()) {
        char c = word[0] - 'a';
        word = word.substr(1);
        if (node->next[c] == nullptr) {
            node->next[c] = new Node;
            node->children++;
        }
        node = node->next[c];
    }
    ++(node->count);
}

void Delete(string word, Node* root) {
    Node* node = root;
    Node* last_word = root;
    string extra_letters = word;

    while (!word.empty()) {
        char c = word[0] - 'a';
        word = word.substr(1);
        node = node->next[c];
        if ((node->count != 0 || node->children > 1) && word.length() > 0) {
            last_word = node;
            extra_letters = word;
        }
    }
    --(node->count);

    if (node->count == 0) {
        char c = extra_letters[0] - 'a';
        extra_letters = extra_letters.substr(1);
        node = last_word->next[c];
        last_word->next[c] = nullptr;
        (last_word->children)--;
        Node* aux;

        while (!extra_letters.empty()) {
            c = extra_letters[0] - 'a';
            extra_letters = extra_letters.substr(1);
            aux = node->next[c];
            delete node;
            node = aux;
        }
        delete node;
    }
}

int Count(string word, Node* root) {
    Node* node = root;


    while (!word.empty()) {
        char c = word[0] - 'a';
        word = word.substr(1);
        if (node->next[c] == nullptr) {
            return 0;
        }
        node = node->next[c];
    }
    return node->count;
}

int Find(string word, Node* root) {
    Node* node = root;
    int length = 0;

    while (!word.empty()) {
        char c = word[0] - 'a';
        word = word.substr(1);
        if (node->next[c] == nullptr) {
            return length;
        }
        node = node->next[c];
        ++length;
    }
    return length;
}

int main() {
    ifstream f("trie.in");
    ofstream g("trie.out");

    int type;
    string word;

    Node* root;
    root = new Node;

    while (f >> type >> word) {
        switch (type) {
            case 0:
                Add(word, root);
                break;
            case 1:
                Delete(word, root);
                break;
            case 2:
                g << Count(word, root) << "\n";
                break;
            case 3:
                g << Find(word, root) << "\n";
                break;
        }
    }

    return 0;
}