#include <bits/stdc++.h>
using namespace std;
 
struct Ahocora{
 
  int idx=0;
 
  struct PMA {
      int state;
      PMA* next[256];
      vector<int> matched;
      PMA(int idx) { memset(next, 0, sizeof(next)); state = idx ; }
      ~PMA() { for(int i = 0; i < 256; i++) if(next[i]) delete next[i]; }
  };
  vector<int> set_uni(const vector<int> &a,const vector<int> &b) {
      vector<int> res;
      set_union(a.begin(),a.end(),b.begin(),b.end(), back_inserter(res));
      return res;
  };
 
  PMA *root;
 
  map<int,PMA*>M;
 
  Ahocora(vector<string> &pattern) {
      root = new PMA(idx++);
      M[idx-1]=root;
      PMA *now;
      root->next[0] = root;
      for(int i = 0; i < pattern.size(); i++) {
          now = root;
          for(int j = 0; j < pattern[i].size(); j++) {
              if(now->next[(int)pattern[i][j]] == 0){
                  now->next[(int)pattern[i][j]] = new PMA(idx++);
                  M[idx-1] = now->next[(int)pattern[i][j]];
                }
              now = now->next[(int)pattern[i][j]];
          }
          now->matched.push_back(i);
      }
 
      queue<PMA*> que;
 
      for(int i=1;i<256;i++){
          if(!root->next[i]) root->next[i] = root;
          else{
              root->next[i]->next[0] = root;
              que.push(root->next[i]);
          }
      }
 
      while(!que.empty()) {
          now = que.front(); que.pop();//cout<<1;
          for(int i = 1; i < 256; i++) {
              if(now->next[i]){
                  PMA *nxt = now->next[0];
                  while(!nxt->next[i]) nxt = nxt->next[0];
                  now->next[i]->next[0] = nxt->next[i];
                  now->next[i]->matched = set_uni(now->next[i]->matched, nxt->next[i]->matched);
                  que.push(now->next[i]);
              }
          }
      }
 
  }
  void match( const string s, vector<int> &res) {
    PMA *pma=root;
      for(int i = 0; i < s.size(); i++){
          int c = s[i];
          while(!pma->next[c]) pma = pma->next[0];
          pma = pma->next[c];
          for(int j = 0; j < pma->matched.size(); j++)
              res[pma->matched[j]] = true;
      }
  }
  typedef pair<string,int>Pi;

 
  pair<int,int> match( const string &s,int S) {
    PMA *pma=M[S];
    int res=0;
      for(int i = 0; i < s.size(); i++){
          int c = s[i];
          while(!pma->next[c]) pma = pma->next[0];
          pma = pma->next[c];
          for(int j = 0; j < pma->matched.size(); j++) res++;
      }
    return make_pair(res,pma->state);
  }
 
  /*  http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2212
  int NG( const string s,int S) {
    PMA *pm = M[S];
    for(int i = 0; i < s.size(); i++){
        int c = s[i];
        while(!pm->next[c]) pm = pm->next[0];
        pm = pm->next[c];
        for(int j = 0; j < pm->matched.size(); j++) return -1;
    }
    return pm->state;
  }
  */
};
 
#define r(i,n) for(int i=0;i<n;i++)
typedef pair<int,int>P;
typedef pair<P,P>P2;
int n,m,k;
 
int main(){
 
  while(1){
    int IDX=0;
    map<P2,int>dp;
    cin>>n>>m>>k;
    if(!n)break;
    string is[n*2];
    map<string,int>si;
    string s[n],t[n],a;
    vector<string>v;
    set<string>st;
    
    vector<int>G[n*2],ALL;
    r(i,n){
      cin>>s[i]>>t[i];

      if(!st.count(s[i])) si[s[i]] = IDX , is[IDX] = s[i] , IDX++,st.insert(s[i]);
      if(!st.count(t[i])) si[t[i]] = IDX , is[IDX] = t[i] , IDX++,st.insert(t[i]);
      G[si[s[i]]].push_back(si[t[i]]); 
    }
    r(i,k){
      cin>>a;

      v.push_back(a);
    }
    Ahocora AHO(v);
    for(int i=0;i<IDX;i++){
      pair<int,int> p=AHO.match(is[i],0);
      int A=is[i].size();
      int B=p.second;
      int C=p.first;
      int D=i;
      if(C>1)continue;
      if(A>m)continue;
      dp[P2(P(A,B),P(D,C))]++;
      //cout<<A<<B<<C<<D<<endl;
    }

    vector< vector< pair<int,int> > > vec[604];

    r(i,AHO.idx){
      vec[i].resize(IDX);
      r(j,IDX){
        r(K,G[j].size()){
          pair<int,int> p = AHO.match(is[G[j][K]],i);
          vec[i][j].push_back(p);
        }
      }
    }

    for(int i=0;i<m;i++){
      for(int j=0;j<AHO.idx;j++){
        for(int K=0;K<2;K++){
          for(int l=0;l<IDX;l++){
 
            if( !dp.count(P2(P(i,j),P(l,K)))  )continue;
 
            for(int z=0;z<G[l].size();z++){
              pair<int,int> p=vec[j][l][z];
              int A=i+is[G[l][z]].size();
              int B=p.second;
              int C=K+p.first;
              int D=G[l][z];
              //cout<<A<<endl;
              if(C>1)continue;
              if(A>m)continue;
              //cout<<A<<endl;
              dp[P2(P(A,B),P(D,C))] += dp[P2(P(i,j),P(l,K))];
              dp[P2(P(A,B),P(D,C))] %= 1000000007;
            }
 
            dp.erase(P2(P(i,j),P(l,K)));
          }
        }
      }
    }
    int ans=0;
    for(int i=0;i<AHO.idx;i++){
      for(int j=0;j<IDX;j++){
        ans += dp[P2(P(m,i),P(j,1))];
        dp.erase(P2(P(m,i),P(j,1)));
        ans %= 1000000007;
      }
    }
    cout<<ans<<endl;
  }
}


Measured memory_bytes: 19424