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

constexpr int nax = 1e9, qax = 100, mod = 1e9 + 7, p = 29, logg = 31;

int n, q, pot[qax + 1];
vector< bool > nop;
vector< bool > vis;
vector< int > hs;
vector< vector< int > > gr;
string tab[qax];
int mat[logg][qax][qax];
int res[2][qax][qax];

int id(const int h)
{
    auto it = lower_bound(begin(hs), end(hs), h) - begin(hs);
    if (it == hs.size()) return -1;
    if (hs[it] != h) return -1;
    return it;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> n >> q;

    pot[0] = 1;

    for (int i = 1; i < qax + 1; ++i)
        pot[i] = ((ll)pot[i - 1] * p) % mod;

    for (int i = 0; i < q; ++i)
    {
        int v; cin >> v;
        cin >> tab[i];
    }

    for (int i = 0; i < q; ++i)
    {
        int h = 0;
        for (int j = 0; j < tab[i].size(); ++j)
        {
            h = (((ll)h * p) + (tab[i][j] - 'a' + 1)) % mod;
            hs.push_back(h);
        }
    }

    hs.push_back(0);
    sort(begin(hs), end(hs));
    hs.resize(unique(begin(hs), end(hs)) - begin(hs));
    nop.resize(hs.size());
    vis.resize(hs.size());
    gr.resize(hs.size(), vector< int >());

    for (int i = 0; i < q; ++i)
    {
        int h = 0;
        for (int j = 0; j < tab[i].size(); ++j)
        {
            h = (((ll)h * p) + (tab[i][j] - 'a' + 1)) % mod;
            int v = id(h);
            if (vis[v]) continue;
            vis[v] = true;
            for (int k = 1; k <= 26; ++k)
            {
                int nh = (((ll)h * p) + k) % mod;
                for (int l = 0; l <= j + 1; ++l)
                {
                    int r = id(nh);
                    if (r >= 0)
                    {
                        gr[v].push_back(r);
                        break;
                    }
                    if (l == j + 1)
                        break;
                    int pt = j - l;
                    int odej = ((ll)pot[pt] * (tab[i][l] - 'a' + 1)) % mod;
                    nh -= odej;
                    if (nh < 0) nh += mod;
                }
            }
        }
        int v = id(h);
        nop[v] = true;
    }

    {
        int cnt = 0;
        int h = 0;
        int v = id(h);
        vis[v] = true;
        for (int k = 0; k <= 26; ++k)
        {
            int nh = (((ll)h * p) + k) % mod;
            for (int l = 0; l <= 0; ++l)
            {
                int r = id(nh);
                if (r >= 0)
                {
                    ++cnt;
                    //cerr << v << ' ' << r << '\n';
                    gr[v].push_back(r);
                    break;
                }
                break;
            }
        }

        mat[0][0][0] += (26 - cnt);
    }
    
    for (int i = 0; i < hs.size(); ++i)
        if (not nop[i])
            for (auto s : gr[i])
                ++mat[0][i][s];

    for (int i = 1; i < logg; ++i)
        for (int j = 0; j < hs.size(); ++j)
            for (int k = 0; k < hs.size(); ++k)
                for (int l = 0; l < hs.size(); ++l)
                {
                    int d = ((ll)mat[i - 1][j][k] * mat[i - 1][k][l]) % mod;
                    mat[i][j][l] += d;
                    if (mat[i][j][l] >= mod)
                        mat[i][j][l] -= mod;
                }

    
    for (int i = 0; i < hs.size(); ++i)
        for (int j = 0; j < hs.size(); ++j)
            res[0][i][j] = mat[0][i][j];

    int nn = n - 1;
    int f = 0;

    for (int i = 0; i < logg; ++i)
        if ((1 << i) & nn)
        {
            for (int i = 0; i < hs.size(); ++i)
                for (int j = 0; j < hs.size(); ++j)
                    res[1 - f][i][j] = 0;

            for (int j = 0; j < hs.size(); ++j)
                for (int k = 0; k < hs.size(); ++k)
                    for (int l = 0; l < hs.size(); ++l)
                    {
                        int d = ((ll)res[f][j][k] * mat[i][k][l]) % mod;
                        res[1 - f][j][l] += d;
                        if (res[1 - f][j][l] >= mod)
                            res[1 - f][j][l] -= mod;
                    }

            f = 1 - f;
        }

    int r = 0;

    for (int j = 0; j < hs.size(); ++j)
        if (not nop[j])
        {
            r += res[f][0][j];
            if (r >= mod) r -= mod;
        }

    cout << r << '\n';
}