#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, a, n) for (int i = (a); i < (n); i++)
#define per(i, a, n) for (int i = (n) - 1; i >= (a); i--)
#define FOR(i, n) rep(i, a, (n))

struct AhoCorasick {
	enum {alpha = 26, first = 'a'};
	struct Node {
		int back, next[alpha], start = -1, end = -1, nmatches = 0;
		Node(int v) { memset(next, v, sizeof(next)); }
	};
	vector<Node> N;
	vector<int> backp;
	void insert(string &s, int j) {
		assert(!s.empty());
		int n = 0;
		for (auto &c : s) {
			//if (N[n].end != -1) break;
			int &m = N[n].next[c - first];
			if (m == -1) { n = m = N.size(); N.emplace_back(-1); }
			else n = m;
		}
		if (N[n].end == -1) N[n].start = j;
		backp.push_back(N[n].end);
		N[n].end = j;
		N[n].nmatches++;
	}
	AhoCorasick(vector<string> &pat) {
		N.emplace_back(-1);
		rep(i, 0, pat.size()) insert(pat[i], i);
		N[0].back = N.size();
		N.emplace_back(0);
		queue<int> q;
		for (q.push(0); !q.empty(); q.pop()) {
			int n = q.front(), prev = N[n].back;
			rep(i, 0, alpha) {
				int &ed = N[n].next[i], y = N[prev].next[i];
				if (ed == -1) ed = y;
				else {
					N[ed].back = y;
					(N[ed].end == -1 ? N[ed].end : backp[N[ed].start])
						= N[y].end;
					N[ed].nmatches += N[y].nmatches;
					q.push(ed);
				}
			}
		}
	}
};

const ll MOD = 1e9 + 7;

template<class T, int N> struct Matrix {
	typedef Matrix M;
	array<array<T, N>, N> d{};
	M operator*(const M& m) const {
		M a;
		rep(i,0,N) rep(j,0,N)
			rep(k,0,N) a.d[i][j] = (a.d[i][j] + d[i][k] * m.d[k][j]) % MOD;
		return a;
	}
	M operator^(ll p) const {
		assert(p >= 0);
		M a, b(*this);
		rep(i,0,N) a.d[i][i] = 1;
		while (p) {
			if (p&1) a = a*b;
			b = b*b;
			p >>= 1;
		}
		return a;
	}
};

int main(void)
{
	ios_base::sync_with_stdio(false);
	ll n;
	int q;
	cin >> n >> q;
	vector<string> pat(q);
	rep(i,0,q) {
		int foo;
		cin >> foo;
		cin >> pat[i];
	}
	sort(pat.begin(), pat.end());
	vector<string> pat2;
	rep(i,0,q) {
		bool ok = true;
		rep(j,0,q) {
			//if (i == j) continue;
			if (pat[i].size() > pat[j].size() &&
					pat[j] == pat[i].substr(0, pat[j].size())) {
				ok = false;
			} else {
			}
		}
		if (ok) pat2.push_back(pat[i]);
	}
	/*rep(i,0,pat2.size()) {
		cout << pat2[i] << endl;
	}*/
	
	AhoCorasick ac(pat2);

	int N = ac.N.size();

	Matrix<ll, 200> m, m2;
	rep(i,0,N) rep(j,0,N) m.d[i][j] = 0;

	rep(i,0,N) {
		if (ac.N[i].end != -1) continue;
		rep(abc,0,26) {
			//cout << i << " " << abc << " " << ac.N[i].next[abc] << endl;
			m.d[i][ac.N[i].next[abc]]++;
		}
	}

	/*rep(i,0,N) {
		rep(j,0,N) {
			cout << m.d[i][j] << " ";
		}
		cout << endl;
	}*/

	m2 = m^n;

	ll res = 0;
	rep(j,0,N) {
		if (ac.N[j].end != -1) continue;
		res = (res + m2.d[0][j]) % MOD;
	}

	cout << res << endl;

	return 0;
}