#include <fstream>
#include <iostream>
#include <vector>
#include <cassert>
#include <set>
#include <unordered_map>
#include <memory>

using namespace std;

struct Node {
    int count, countEdges;
    Node* edges[26];

    Node() {
        count = 0;
        countEdges = 0;
        memset(edges, 0, sizeof(edges));
    }
};

void add(Node& root, const string& s) {
    Node* n = &root;
    for (int p = 0; p < s.size(); p++) {
        int c = s[p] - 'a';
        if (n->edges[c] == nullptr) {
            n->edges[c] = new Node();
            n->countEdges++;
        }
        n = n->edges[c];
    }
    ++n->count;
}

bool remove(Node& n, const string& s, int p) {
    if (p >= s.size()) {
        assert(n.count > 0);
        --n.count;
        return n.count <= 0 && n.countEdges <= 0;
    }

    int c = s[p] - 'a';

    assert(n.edges[c] != nullptr);
    bool shouldRemove = remove(*(n.edges[c]), s, p + 1);

    if (shouldRemove) {
        delete n.edges[c];
        n.edges[c] = nullptr;
        n.countEdges--;
    }
    
    return n.count <= 0 && n.countEdges <= 0;
}

int count(const Node& root, const string& s) {
    Node const* n = &root;

    for (int p = 0; p < s.size(); p++) {
        int c = s[p] - 'a';
        if (n->edges[c] == nullptr)
            return 0;
        n = n->edges[c];
    }

    return n->count;
}

int maxLen(const Node& root, const string& s) {
    Node const* n = &root;

    for (int p = 0; p < s.size(); p++) {
        int c = s[p] - 'a';
        if (n->edges[c] == nullptr)
            return p;
        n = n->edges[c];
    }

    return s.size();
}

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

    Node root;
    int op;
    string s;

    while (f >> op >> s) {
        
        if (op == 0)
            add(root, s);
        else if (op == 1)
            remove(root, s, 0);
        else if (op == 2)
            g << count(root, s) << '\n';
        else if (op == 3)
            g << maxLen(root, s) << '\n';
    }

    f.close();
    g.close();
    return 0;
}