#include <stdio.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <string.h>
using namespace std;
typedef struct my_set my_set;

typedef struct node{
  char key;  
  int nr;
  my_set* child;
}node;
struct compare_nodes{
  bool operator()(node *a,node *b) const
  {
    if (a->key<b->key) return true;
    return false;
  }
};
struct  my_set{
  set<node*, compare_nodes> s;
};


void insert_trie(char *key,int index,node *T)
{
   int l = strlen(key);  
   node *nn= new node;
   nn->key = key[index];
   nn->nr = 0;   
   //cout<<index+1<<endl;   
   nn->child = new my_set;
   pair<set<node*,compare_nodes>::iterator,bool> it =T->child->s.insert(nn);
   node *x = *(it.first);   
   if (!it.second)
     delete nn;
   if (index<l-1)
   {   
     insert_trie(key,index+1,x);
   }
   else
   {
    (x->nr)++;
   }
}
bool delete_trie(char *key,int index,node *T)
{
   int l = strlen(key);  
   node *nn= new node;
   nn->key = key[index];
   set<node*,compare_nodes>::iterator it =T->child->s.find(nn);   
   if (it==T->child->s.end())
   {
     delete nn;
     return false;
   }
   else {
     delete nn;
     node *x = (*it);
     bool b;
     if (index!=l-1){                     
        b = delete_trie(key,index+1,x);       
      }
     else {
        (x->nr)--;
        b=true;     
     }
      if (x->child->s.empty() && x->nr==0)
        {
          T->child->s.erase(x);
          delete x->child;
          delete x;          
        }
     return b;
    }      
}
int howmany(char *key,int index, node* T)
{
   int l = strlen(key);  
   node *nn= new node;
   nn->key = key[index];
   set<node*,compare_nodes>::iterator it =T->child->s.find(nn);   
   delete nn;
   if (it==T->child->s.end())
     return 0;
   else {
     node *x = (*it);
    if (index==l-1)
      return x->nr;
    else return howmany(key,index+1,x);   
   }
}
int pref_len(char *key,int index,node *T)
{
  int l = strlen(key);
  node *nn = new node;
  nn->key = key[index];
  set<node*,compare_nodes>::iterator it =T->child->s.find(nn);
  if (it==T->child->s.end())
    return index;
  else
  {
   if (index==l-1)
     return l;
   else 
     return pref_len(key,index+1,(*it));
  }
}
int main()
{
  ifstream f("trie.in");
  ofstream g("trie.out");
  node *T = new node;
  T->child = new my_set;
  int type;
  while (!f.eof())
  {
    type=-1;
    char str[21];
    f>>type>>str;
    switch (type){
    case 0:insert_trie(str,0,T);
     break;
    case 1:delete_trie(str,0,T);
      break;
    case 2:g<<howmany(str,0,T)<<"\n";
      break;
    case 3:g<<pref_len(str,0,T)<<"\n";
      break;
    default:
      break;
    }
  }
  f.close();
  g.close();
}