#include <fstream>
#include <algorithm>
#include <cstring>
#include <string>
#define maxNumber 30
using namespace std;

ifstream fin("trie.in");
ofstream fout("trie.out");

class Trie{
public:
    // data structures
    int cnt = 0, SonsNumber = 0;
    Trie *sons[maxNumber];
    // constructors
    Trie()
    {
        cnt = SonsNumber = 0;
        memset(sons,0,sizeof(sons));
    }

    void Insert(Trie *node, string str);
    int Delete(Trie *node, string str);
    int LCP(Trie *node, string str, int k);
    int Number(Trie *node, string str);

};

void Trie :: Insert(Trie *node, string str){
    if(str.size() == 0)
    {
        node->cnt++;
        return;
    }

    if(node->sons[str[0] - 'a'] == 0)
    {
        node->sons[str[0] - 'a'] = new Trie;
        node->SonsNumber++;
    }

    Insert(node->sons[str[0] - 'a'],str.substr(1));

}

int Trie :: Delete(Trie *node,string str){
    if(!str.size())
        node->cnt--;
    else if(Delete(node->sons[str[0] - 'a'],str.substr(1)))
    {
        node->sons[str[0] - 'a'] = 0;
        node->SonsNumber--;
    }

    if(node->cnt == 0 && node->SonsNumber == 0 && node != this)
    {
        delete node;
        return 1;
    }

    return 0;
}

int Trie :: Number(Trie *node,string str){
    if(!str.size())
    {
        return node->cnt;

    }

    if(node->sons[str[0] - 'a'] != 0)
        return Number(node->sons[str[0] - 'a'],str.substr(1));
    return 0;
}

int Trie :: LCP(Trie *node,string str, int k){
    if(!str.size() || node->sons[str[0] - 'a'] == 0)
        return k;
    return LCP(node->sons[str[0] - 'a'],str.substr(1),k + 1);

}

Trie *trie = new Trie;
string str;

int main()
{
    int type;
    while(fin >> type)
    {
        fin >> str;
        if(type == 0)
            trie->Insert(trie,str);
        if(type == 1)
            trie->Delete(trie,str);
        if(type == 2)
            fout << trie->Number(trie,str) << "\n";
        if(type == 3)
            fout << trie->LCP(trie,str,0) << "\n";
    }
    return 0;
}