#include<bits/stdc++.h>
using namespace std;

template<typename S>
struct dynamic_rolling_hash
{
    using dat=array<long long,2>;
    dynamic_rolling_hash():dynamic_rolling_hash(0,0){}
    dynamic_rolling_hash(int _n, long long _b):dynamic_rolling_hash(vector<S>(_n)){}
    dynamic_rolling_hash(const vector<S>&_v):n(_v.size())
    {
        init();
        log=0;
        while((1<<log)<n)log++;
        sz=1<<log;
        node.resize(2*sz,e());
        for(int i=0;i<n;i++)for(int j=0;j<2;j++)
        {
            node[i+sz].first[j]=inner_hash(_v[i],j);
            node[i+sz].second=1;
        }
        for(int i=sz-1;i>=1;i--)update(i);
    }
    static void set_base(long long b){base=b;}
    void set(int p, S x)
    {
        p+=sz;
        for(int j=0;j<2;j++)node[p].first[j]=inner_hash(x,j);
        node[p].second=1;
        for(int i=1;i<=log;i++)update(p>>i);
    }
    pair<dat,int> prod(int l, int r)
    {
        auto pl=e(),pr=e();
        l+=sz,r+=sz;
        while(l<r)
        {
            if(l&1)pl=op(pl,node[l++]);
            if(r&1)pr=op(node[--r],pr);
            l>>=1,r>>=1;
        }
        return op(pl,pr);
    }
    pair<dat,int> all_prod(){return node[1];}
private:
    int n,log,sz;
    static long long base;
    static constexpr dat mod=dat{94663399,1000100033};
    static vector<dat>mod_pow;
    vector<pair<dat,int>>node;
    long long inner_hash(S x, int p){return base^(base-x);}
    pair<dat,int>op(const pair<dat,int>&a, const pair<dat,int>&b)
    {
        dat c;
        for(int i=0;i<2;i++)c[i]=(a.first[i]+b.first[i]*mod_pow[a.second][i])%mod[i];
        return make_pair(c,a.second+b.second);
    }
    pair<dat,int>e(){return make_pair(dat(),0);}
    void update(int p){node[p]=op(node[2*p],node[2*p+1]);}
    void init()
    {
        assert(base>0);
        if(int(mod_pow.size())>=n)return;
        int d=mod_pow.size();
        mod_pow.resize(max(n+1,2*d));
        for(int i=d;i<int(mod_pow.size());i++)for(int j=0;j<2;j++)
        {
            mod_pow[i][j]=(mod_pow[i-1][j]*base)%mod[j];
        }
    }
};
template<typename S>
vector<array<long long,2>>dynamic_rolling_hash<S>::mod_pow(1,{1,1});
template<typename S>
long long dynamic_rolling_hash<S>::base=-1;
int N,L,Q;
string S[1010];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    srand(time(NULL));
    int b=rand()%(1<<30);
    dynamic_rolling_hash<int>::set_base(b);
    cin>>N>>L>>Q;
    vector<dynamic_rolling_hash<int>>RH;
    for(int i=0;i<N;i++)
    {
        cin>>S[i];
        vector<int>v(L);
        for(int j=0;j<L;j++)v[j]=S[i][j];
        RH.push_back(dynamic_rolling_hash<int>(v));
    }
    while(Q--)
    {
        int t;
        cin>>t;
        if(t==1)
        {
            int p;
            char c,d;
            cin>>p>>c>>d;
            p--;
            for(int i=0;i<N;i++)if(S[i][p]==c)
            {
                S[i][p]=d;
                RH[i].set(p,int(d));
            }
        }
        else
        {
            string T;
            cin>>T;
            vector<int>v;
            for(char c:T)v.push_back(int(c));
            auto hashT=dynamic_rolling_hash(v).all_prod();
            int ans=0;
            for(int i=0;i<N;i++)
            {
                auto hashS=RH[i].prod(0,T.size());
                if(hashS==hashT)ans++;
            }
            cout<<ans<<'\n';
        }
    }
}