#include <stdio.h>

 #include <algorithm>

 #include <string.h>

 #include <vector>

 #include <queue>

 #include <iostream>

 using namespace std;

 const int MAX_Tot =  + ;

 const int mod = ;

 typedef unsigned long long ull;

 int m,n;

 struct matrix

 {

     ull e[MAX_Tot][MAX_Tot];

     int n,m;

     matrix() {}

     matrix(int _n,int _m): n(_n),m(_m) {memset(e,,sizeof(e));}

     matrix operator * (const matrix &temp)const

     {

         matrix ret = matrix(n,temp.m);

         for(int i=;i<=ret.n;i++)

         {

             for(int j=;j<=ret.m;j++)

             {

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

                 {

                     ret.e[i][j] += e[i][k]*temp.e[k][j];

                 }

             }

         }

         return ret;

     }

     matrix operator + (const matrix &temp)const

     {

         matrix ret = matrix(n,m);

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

         {

             for(int j=;j<=m;j++)

             {

                 ret.e[i][j] += e[i][j]+temp.e[i][j];

             }

         }

         return ret;

     }

     void getE()

     {

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

         {

             for(int j=;j<=m;j++)

             {

                 e[i][j] = i==j?:;

             }

         }

     }

 };

 matrix qpow(matrix temp,int x)

 {

     int sz = temp.n;

     matrix base = matrix(sz,sz);

     base.getE();

     while(x)

     {

         if(x & ) base = base * temp;

         x >>= ;

         temp = temp * temp;

     }

     return base;

 }

 matrix solve(matrix a, int k)

 {

     if(k == ) return a;

     int n = a.n;

     matrix temp = matrix(n,n);

     temp.getE();

     if(k & )

     {

         matrix ex = qpow(a,k);

         k--;

         temp = temp + qpow(a,k/);

         return temp * solve(a,k/) + ex;

     }

     else

     {

         temp = temp + qpow(a,k/);

         return temp * solve(a,k/);

     }

 }

 struct Aho

 {

     struct state

     {

         int nxt[];

         int fail,cnt;

     }stateTable[MAX_Tot];

     int size;

     queue<int> que;

     void init()

     {

         while(que.size()) que.pop();

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

         {

             memset(stateTable[i].nxt,,sizeof(stateTable[i].nxt));

             stateTable[i].fail = stateTable[i].cnt = ;

         }

         size = ;

     }

     void insert(char *s)

     {

         int n = strlen(s);

         int now = ;

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

         {

             char c = s[i];

             if(!stateTable[now].nxt[c-'a'])

                 stateTable[now].nxt[c-'a'] = size++;

             now = stateTable[now].nxt[c-'a'];

         }

         stateTable[now].cnt = ;

     }

     void build()

     {

         stateTable[].fail = -;

         que.push();

         while(que.size())

         {

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

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

             {

                 if(stateTable[u].nxt[i])

                 {

                     if(u == ) stateTable[stateTable[u].nxt[i]].fail = ;

                     else

                     {

                         int v = stateTable[u].fail;

                         while(v != -)

                         {

                             if(stateTable[v].nxt[i])

                             {

                                 stateTable[stateTable[u].nxt[i]].fail = stateTable[v].nxt[i];

                                 // 在匹配fail指针的时候顺便更新cnt

                                 if(stateTable[stateTable[stateTable[u].nxt[i]].fail].cnt == )

                                     stateTable[stateTable[u].nxt[i]].cnt = ;

                                 break;

                             }

                             v = stateTable[v].fail;

                         }

                         if(v == -) stateTable[stateTable[u].nxt[i]].fail = ;

                     }

                     que.push(stateTable[u].nxt[i]);

                 }

                 /*****建立自动机nxt指针*****/

                 else

                 {

                     if(u == ) stateTable[u].nxt[i] = ;

                     else

                     {

                         int p = stateTable[u].fail;

                         while(p != - && stateTable[p].nxt[i] == ) p = stateTable[p].fail;

                         if(p == -) stateTable[u].nxt[i] = ;

                         else stateTable[u].nxt[i] = stateTable[p].nxt[i];

                     }

                 }

                 /*****建立自动机nxt指针*****/

             }

         }

     }

     matrix build_matrix()

     {

         matrix ans = matrix(size,size);

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

         {

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

             {

                 if(!stateTable[i].cnt && !stateTable[stateTable[i].nxt[j]].cnt)

                     ans.e[i+][stateTable[i].nxt[j]+]++;

             }

         }

         return ans;

     }

 }aho;

 void print(matrix p)

 {

     int n = p.n;

     int m = p.m;

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

     {

         for(int j=;j<=m;j++)

         {

             printf("%d ",p.e[i][j]);

         }

         puts("");

     }

 }

 int main()

 {

     while(scanf("%d%d",&m,&n) == )

     {

         aho.init();

         char s[];

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

         {

             scanf("%s",s);

             aho.insert(s);

         }

         aho.build();

         matrix p = aho.build_matrix();

         p = solve(p,n);

         ull temp = ;

         for(int i=;i<=aho.size;i++) temp += p.e[][i];

         matrix t = matrix(,);

         t.e[][] = ;

         matrix A = matrix(,);

         A.e[][] = A.e[][] = ; A.e[][] = ;

         t = t * qpow(A,n);

         ull ans = t.e[][] - temp;

         printf("%llu\n",ans);

     }

     return ;

 }