#include<cstdio>

 #include<cstring>

 #include<queue>

 #include<algorithm>

 using namespace std;

 int tn,ch[][],fail[],flag[];

 void insert(unsigned char *s){

     int x=;

     for(int i=; s[i]; ++i){

         int y=s[i];

         if(ch[x][y]==) ch[x][y]=++tn;

         x=ch[x][y];

     }

     flag[x]=;

 }

 void init(){

     memset(fail,,sizeof(fail));

     queue<int> que;

     for(int i=; i<; ++i){

         if(ch[][i]) que.push(ch[][i]);

     }

     while(!que.empty()){

         int x=que.front(); que.pop();

         for(int i=; i<; ++i){

             if(ch[x][i]) que.push(ch[x][i]),fail[ch[x][i]]=ch[fail[x]][i],flag[ch[x][i]]|=flag[ch[fail[x]][i]];

             else ch[x][i]=ch[fail[x]][i];

         }

     }

 }

 #define ULL unsigned long long

 #define M 1000000000000000000L

 struct BigInt{

     ULL bit[];

     BigInt(int a=){

         bit[]=bit[]=bit[]=bit[]=;

         bit[]=a;

     }

 };

 BigInt operator+(const BigInt &b1,const BigInt &b2){

     BigInt b;

     ULL carry=;

     for(int i=; i>=; --i){

         ULL tmp=b1.bit[i]+b2.bit[i]+carry;

         b.bit[i]=tmp%M;

         carry=tmp/M;

     }

     return b;

 };

 void output(const BigInt &b){

     int i=;

     while(i< && b.bit[i]==) ++i;

     if(i==){

         puts("");

         return;

     }

     printf("%llu",b.bit[i]);

     for(int j=i+; j<; ++j){

         printf("%018llu",b.bit[j]);

     }

     putchar('\n');

 }

 int main(){

     BigInt one();

     unsigned char str[];

     int n,m,p;

     while(~scanf("%d%d%d",&n,&m,&p)){

         scanf("%s",str);

         bool vis[]={};

         for(int i=; str[i]; ++i) vis[str[i]]=;

         tn=;

         memset(ch,,sizeof(ch));

         memset(flag,,sizeof(flag));

         for(int i=; i<p; ++i){

             scanf("%s",str);

             insert(str);

         }

         init();

         BigInt **d=new BigInt*[m+];

         for(int i=; i<=m; ++i) d[i]=new BigInt[tn+];

         d[][]=one;

         for(int i=; i<m; ++i){

             for(int j=; j<=tn; ++j){

                 if(flag[j]) continue;

                 for(int k=; k<; ++k){

                     if(!vis[k] || flag[ch[j][k]]) continue;

                     d[i+][ch[j][k]]=d[i+][ch[j][k]]+d[i][j];

                 }

             }

         }

         BigInt res=;

         for(int i=; i<=tn; ++i) res=res+d[m][i];

         output(res);

         for(int i=; i<=m; ++i) delete[] d[i];

         delete[] d;

     }

     return ;

 }