#include<stdio.h>

#include<string.h>

#include<algorithm>

#include<queue>

#include<iostream>

using namespace std;

const int MAXN = ;

const int MAXM = ;

const int mod  = ;

struct Matrix

{///定义矩阵

    int size;

    unsigned long long edge[MAXN][MAXN];

    Matrix(int Len)

    {

        size = Len;

        memset(edge, false, sizeof(edge));

    }

    Matrix operator *(const Matrix &Map) const

    {

        Matrix ans(size);

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

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

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

        {

            ans.edge[i][j] += edge[i][k] * Map.edge[k][j];

        }

        return ans;

    }

};

struct Ac_Trie

{

    int next[MAXN][MAXM];

    int fail[MAXN], End[MAXN];

    int Len, root;

    Ac_Trie()

    {

        memset(next, -, sizeof(next));

        memset(End, false, sizeof(End));

        Len = , root = ;

    }

    void Insert(char s[])

    {

        int p = root;

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

        {

            int k = s[i] - 'a';

            if(next[p][k] == -)

                next[p][k] = Len++;

            p = next[p][k];

        }

        End[p] = true;

    }

    void GetFail()

    {

        queue<int> Q;

        int p = root;

        fail[p] = root;

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

        {

            if(next[p][i] == -)

                next[p][i] = root;

            else

            {

                fail[next[p][i]] = root;

                Q.push(next[p][i]);

            }

        }

        while(Q.size())

        {

            p = Q.front();

            Q.pop();

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

            {

                if(next[p][i] == -)

                    next[p][i] = next[fail[p]][i];

                else

                {

                    fail[next[p][i]] = next[fail[p]][i];

                    Q.push(next[p][i]);

                }

            }

            End[p] |= End[fail[p]];

        }

    }

    Matrix GetMatrix()

    {

        Matrix ans(Len+);

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

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

        {

            if(End[next[i][k]] == false)

                ans.edge[i][next[i][k]] += ;

        }

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

            ans.edge[i][Len] = ;

        return ans;

    }

};

Matrix QuickPow(long long K, Matrix Map)

{

    Matrix ans(Map.size);

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

        ans.edge[i][i] = ;

    while(K)

    {

        if(K & )

            ans = ans * Map;

        Map = Map * Map;

        K /= ;

    }

    return ans;

}

int main()

{

    long long N, L;

    while(scanf("%lld%lld", &N, &L) != EOF)

    {

        char s[MAXN];

        Ac_Trie a;

        while(N--)

        {

            scanf("%s", s);

            a.Insert(s);

        }

        a.GetFail();

        Matrix ans = a.GetMatrix();

        unsigned long long sum1=, sum=;

        ans = QuickPow(L, ans);

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

            sum1 += ans.edge[][i];

        ans.size = ;

        ans.edge[][] = ;

        ans.edge[][] = ;

        ans.edge[][] = ans.edge[][] = ;

        ans = QuickPow(L, ans);

        sum = ans.edge[][] + ans.edge[][];

        cout << sum - sum1 <<endl;

    }

    return ;

}