#include <cstring>
#include <fstream>
#include <memory>

using namespace std;

// Questions:
// (*currentNode).count <=> currentNode->count

const int ALPHA = 26;

struct TrieNode {
    int count;
    int leaf;
    shared_ptr<TrieNode> next[ALPHA];
    TrieNode() : count(0), leaf(0) {
        fill(next, next + ALPHA, shared_ptr<TrieNode>(nullptr));
    }
};

void insert(shared_ptr<TrieNode>& currentNode, int currentIndex, const string& currentSeq) {
    currentNode -> count += 1;
    if (currentIndex == currentSeq.size()) {
        currentNode -> leaf += 1;
        return;
    }
    auto nextChar = currentSeq[currentIndex] - 'a';
    if (currentNode->next[nextChar] == nullptr) {
        currentNode->next[nextChar] = make_shared<TrieNode>();
    }
    insert(currentNode->next[nextChar], currentIndex + 1, currentSeq);
}

void erase(shared_ptr<TrieNode>& currentNode, int currentIndex, const string& currentSeq) {
    currentNode -> count -= 1;
    if (currentIndex == currentSeq.size()) {
        currentNode -> leaf -= 1;
        return;
    }
    auto nextChar = currentSeq[currentIndex] - 'a';
    erase(currentNode->next[nextChar], currentIndex + 1, currentSeq);
    if (currentNode->next[nextChar] -> count == 0) {
        currentNode->next[nextChar] = nullptr;
    }
}

int count(const shared_ptr<TrieNode>& currentNode, int currentIndex, const string& currentSeq) {
    if (currentIndex == currentSeq.size()) {
        return currentNode->leaf;
    }
    auto nextChar = currentSeq[currentIndex] - 'a';
    if (currentNode->next[nextChar])
        return count(currentNode->next[nextChar], currentIndex + 1, currentSeq);
    return 0;
}

int lcp(const shared_ptr<TrieNode>& currentNode, int currentIndex, const string& currentSeq) {
    if (currentNode == nullptr or currentIndex == currentSeq.size()) {
        return currentIndex - (currentNode == nullptr);
    }
    auto nextChar = currentSeq[currentIndex] - 'a';
    return lcp(currentNode->next[nextChar], currentIndex + 1, currentSeq);
}

int main() {
    ifstream cin ("trie.in");
    ofstream cout ("trie.out");
    int type;
    string word;
    auto Root = make_shared<TrieNode>();
    while (cin >> type >> word) {
        switch (type) {
            case 0:
                insert(Root, 0, word);
                break;
            case 1:
                erase(Root, 0, word);
                break;
            case 2:
                cout << count(Root, 0, word) << '\n';
                break;
            default:
                cout << lcp(Root, 0, word) << '\n';
        }
    }
    return 0;
}