#include <bits/stdc++.h>

typedef unsigned long long ull;

const int P = 1000000007;

int norm(int x) { return x >= P ? x - P : x; }
int reduce(int x) { return x < 0 ? x + P : x; }
int neg(int x) { return x ? P - x : 0; }
void add(int& x, int y) { if ((x += y - P) < 0) x += P; }
void sub(int& x, int y) { if ((x -= y) < 0) x += P; }
void fam(int& x, int y, int z) { x = (x + y * (ull)z) % P; }
int mpow(int x, unsigned k) {
	if (k == 0) return 1;
	int ret = mpow(x * (ull)x % P, k >> 1);
	if (k & 1) ret = ret * (ull)x % P;
	return ret;
}

int popcnt(int x) { return __builtin_popcount(x); }

const int N = 32, M = 1010;

int n, m, high;
char str[110];

int len[M];
unsigned mask[M][4];
unsigned tmp[4];

int pw2[M], pw3[M];
int dp[1 << (N / 2)], tdp[1 << (N / 2)];
int memo[1 << (N / 2)];
int mem[1 << (N / 2)], mem2[1 << (N / 2)];
int memc1[1 << (N / 2)], memc2[1 << (N / 2)], mem2c1[1 << (N / 2)], mem2c2[1 << (N / 2)];
unsigned bitrev[1 << (N / 2)];

void supsum(int* a, int l) {
	for (int i = 0; i != l; ++i) for (int j = 0; j != 1 << l; ++j)
		if ((j >> i) & 1)
			a[j ^ 1 << i] += a[j];
}

bool subset(unsigned x, unsigned y) { return (x & y) == x; }

void dfs1(int i, unsigned ori, unsigned rev, int carry) {
	if (i == high) {
		bitrev[ori] = (rev << 1) | 1;
		memo[ori] = carry;
		return;
	}
	for (int b = 0; b <= 1; ++b) {
		unsigned nori = ori | (b << i), nrev = (rev << 1) | b;
		int ncarry = b ? P - carry : carry;
		ncarry = ncarry * (ull)pw2[memc1[nrev] - 2 * memc2[nrev]] % P * (ull)pw3[memc2[nrev]] % P;
		dfs1(i + 1, nori, nrev, ncarry);
	}
}

void dfs2(int i, unsigned ori, unsigned rev, int carry0, int carry1) {
	if (i == 0) {
		memo[ori] = memo[ori] * (ull)carry0 % P;
		memo[ori + 1] = memo[ori + 1] * (ull)carry1 % P;
		return;
	}
	for (int b = i == high; b <= 1; ++b) {
		unsigned nori = ori | (b << i), nrev = (rev >> 1) | (b << (high - 1));
		int nc0 = b ? carry1 : carry0, nc1 = carry1;
		nc1 = nc1 * (ull)pw2[memc1[nrev] - 2 * memc2[nrev]] % P * (ull)pw3[memc2[nrev]] % P;
		nc0 = nc0 * (ull)pw2[mem2c1[nrev] - 2 * mem2c2[nrev]] % P * (ull)pw3[mem2c2[nrev]] % P;
		dfs2(i - 1, nori, nrev, nc0, nc1);
	}
}

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

	std::cin >> n >> m;
	pw2[0] = 1;
	for (int i = 1; i <= m; ++i) pw2[i] = norm(pw2[i - 1] << 1);
	pw3[0] = 1;
	for (int i = 1; i <= m; ++i) pw3[i] = pw3[i - 1] * 3ULL % P;
	for (int i = 0; i != m; ++i) {
		std::cin >> str;
		int k = 1, b = 0;
		auto stab = [&]() {
			for (int in = 0; in <= 1; ++in) {
				int out = (k * in + b) & 1;
				mask[i][in * 2 + out] |= 1U << len[i];
			}
			k = 1; b = 0;
		};
		for (char* p = str; *p; ++p) {
			switch (*p) {
			case 'R': stab(); ++len[i]; break;
			case '0':
			case '1': k = 0; b = *p - '0'; break;
			case '*': b ^= 1; break;
			}
			if (len[i] == n) break;
		}
		if (len[i] < n) {stab();}
		for (int j = len[i] + 1; j < n; ++j) {
			mask[i][0] |= 1U << j;
			mask[i][3] |= 1U << j;
		}
	}
	int ans = 0;
	for (high = 0; high != (n + 1) / 2; ++high) {
		memset(memc1, 0, sizeof(int) << high); memset(memc2, 0, sizeof(int) << high);
		for (int j = 0; j != m; ++j) if (len[j] < n - high) {
			static int shrink[4];
			for (int k = 0; k != 4; ++k) shrink[k] = mask[j][k] & ((1 << high) - 1);
			++memc1[shrink[0]]; ++memc1[shrink[3]];
			++memc2[shrink[0] & shrink[3]];
		}
		supsum(memc1, high); supsum(memc2, high);
		dfs1(0, 1U << high, 0, 1);
		for (int i = 0; i != n - high * 2; ++i) {
			memset(memc1, 0, sizeof(int) << (high + 1)); memset(memc2, 0, sizeof(int) << (high + 1));
			for (int j = 0; j != m; ++j) if (len[j] < n - high) {
				static int shrink[4];
				for (int k = 0; k != 4; ++k) shrink[k] = (mask[j][k] >> i) & ((2 << high) - 1);
				for (int k = 0; k != 4; ++k) ++memc1[shrink[k]];
				for (int k = 0; k != 4; ++k) for (int l = k + 1; l != 4; ++l)
					++memc2[shrink[k] & shrink[l]];
			}
			supsum(memc1, high + 1); supsum(memc2, high + 1);
			for (int j = 1 << high; j != 2 << high; ++j) {
				int c1 = memc1[bitrev[j]], c2 = memc2[bitrev[j]];
				memo[j] = memo[j] * (ull)pw2[c1 - c2 * 2] % P * pw3[c2] % P;
			}
		}
		if (high) {
			memset(memc1, 0, sizeof(int) << high); memset(memc2, 0, sizeof(int) << high);
			memset(mem2c1, 0, sizeof(int) << high); memset(mem2c2, 0, sizeof(int) << high);
			for (int j = 0; j != m; ++j) if (len[j] < n - high) {
				static int shrink[4];
				for (int k = 0; k != 4; ++k) shrink[k] = (mask[j][k] >> (n - high * 2)) & ((1 << high) - 1);
				++memc1[shrink[0]]; ++memc1[shrink[3]];
				++memc2[shrink[0] & shrink[3]];
				for (int k = 0; k != 4; ++k) ++mem2c1[shrink[k]];
				for (int k = 0; k != 4; ++k) for (int l = k + 1; l != 4; ++l)
					++mem2c2[shrink[k] & shrink[l]];
			}
			supsum(memc1, high); supsum(memc2, high);
			supsum(mem2c1, high); supsum(mem2c2, high);
			dfs2(high, 0, 0, 1, 1);
		}
	}
	for (int i = 1; i != 1 << high; ++i) add(ans, memo[i]);

	for (high = (n + 1) / 2; high != n; ++high) {
		int l = n - high - 1;
		memset(dp, 0, sizeof(int) << l);
		memset(memc1, 0, sizeof(int) << (l + 1)); memset(memc2, 0, sizeof(int) << (l + 1));
		memset(mem2c1, 0, sizeof(int) << (l + 1)); memset(mem2c2, 0, sizeof(int) << (l + 1));
		for (int j = 0; j != m; ++j) if (len[j] <= l) {
			static int shrink[4];
			for (int k = 0; k != 4; ++k) shrink[k] = mask[j][k] & ((2 << l) - 1);
			++memc1[shrink[0]]; ++memc1[shrink[3]];
			++memc2[shrink[0] & shrink[3]];
			for (int k = 0; k != 4; ++k) ++mem2c1[shrink[k]];
			for (int k = 0; k != 4; ++k) for (int l = k + 1; l != 4; ++l)
				++mem2c2[shrink[k] & shrink[l]];
		}
		supsum(memc1, l + 1); supsum(memc2, l + 1);
		supsum(mem2c1, l + 1); supsum(mem2c2, l + 1);
		for (int s = 0; s != 2 << l; ++s) {
			if (!s) {
				mem[s] = 1; mem2[s] = 1;
				for (int j = 0; j != m; ++j) if (len[j] <= l) {
					int cnt = 1;
					cnt += subset(s, mask[j][0]);
					cnt += subset(s, mask[j][3]);
					mem[s] = unsigned(mem[s]) * unsigned(cnt) % P;
					cnt += subset(s, mask[j][1]);
					cnt += subset(s, mask[j][2]);
					mem2[s] = unsigned(mem2[s]) * unsigned(cnt) % P;
				}
			} else {
				mem[s] = pw2[memc1[s] - 2 * memc2[s]] * (ull)pw3[memc2[s]] % P;
				mem2[s] = pw2[mem2c1[s] - 2 * mem2c2[s]] * (ull)pw3[mem2c2[s]] % P;
			}
		}
		for (int s = 0; s != 2 << l; s += 2) {
			int prod = __builtin_parity(s) ? P - 1 : 1, prod2 = prod;
			unsigned ms = s + 1;
			for (int rep = 0; rep <= l; ++rep) {
				if (ms >= (2 << l)) {
					prod = prod * (ull)mem[ms & ((2 << l) - 1)] % P;
					prod2 = prod2 * (ull)mem[ms & ((2 << l) - 1)] % P;
				} else {
					prod = prod * (ull)mem[ms] % P;
					prod2 = prod2 * (ull)mem2[ms] % P;
				}
				ms <<= 1;
			}
			dp[s >> 1] = prod;
			sub(prod2, prod);
			ms = s + 1;
			for (int i = high - 1; i >= 0; --i) {
				ms >>= 1;
				prod2 = prod2 * (ull)mem[ms] % P;
			}
			add(ans, prod2);
		}
		for (int i = high - 1; i >= l; --i) {
			memset(tdp, 0, sizeof(int) << l);
			for (int s = 0; s != 1 << l; ++s) {
				for (int b = 0; b <= 1; ++b) {
					unsigned ms = s | (b << l);
					if (b) fam(tdp[(s + (b << l)) >> 1], dp[s], P - mem[ms]);
					else fam(tdp[(s + (b << l)) >> 1], dp[s], mem[ms]);
				}
			}
			memcpy(dp, tdp, sizeof(int) << l);
		}
		for (int s = 0; s != 1 << l; ++s) {
			int prod = dp[s];
			unsigned ms = s;
			for (int rep = 0; rep != l; ++rep) {
				prod = prod * (ull)mem[ms] % P;
				ms >>= 1;
			}
			add(ans, prod);
		}
	}
	std::cout << ans << '\n';

	return 0;
}