#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

#define MR 1000010
#define MOD 1000000007

const int p = 70032301;
const int q = 1000000007;

int potP[MR];

typedef pair < int, pair<vector<int>, string>> clause;

clause t[MR];

// zwroc hashe, poczatek przedzialu oraz stringa dla klauzuli
// beg - pierwszy za nawiasem klauzuli, end - ostatni nawias w klauzuli
clause parseClause(int beg, int end, const string &line)
{
	vector < pair <int, bool> > literals;

	for (int i = beg; i < end;)
	{
		if (line[i] == 'x' || line[i] == '~')
		{
			bool v = 1;
			if (line[i] == '~')
			{
				v = 0;
				i++;
			}

			int j = i + 1;
			int nr = 0;
			while (j < end && line[j] != ' ')
			{
				nr *= 10;
				nr += line[j] - '0';
				j++;
			}

			literals.push_back(MP(nr, v));

			i = j;
		}
		else
			i++;
	}

	sort(literals.begin(), literals.end());

	string s = "";
	REP(i, literals.size())
		s += literals[i].second + '0';

	//wylicz hasze
	vector < int > h(s.length() + 1);
	h.back() = 0;
	FORD(i, s.length(), 0) h[i] = (h[i + 1] * (LL)p + s[i]) % q;

	return MP(literals.front().first, MP(h, s));
}

// return number of clauses
int parseLine(const string &line)
{
	int akt = 0;
	for (int i = 0; i < line.length();)
	{
		if (line[i] == '(')
		{
			int j = i + 1;
			while (line[j] != ')')
				j++;
			t[akt++] = parseClause(i + 1, j, line);
			i = j;
		}
		else
			i++;
	}

	return akt;
}

/***szybkie potegowanie***/
int square(int x)
{
	return (x * (LL)x) % MOD;
}
int bigmod(int b, int w, int p) {
	if (w == 0)
		return 1;
	else if (w % 2 == 0)
		return square(bigmod(b, w / 2, p)) % p; // square(x) = x * x
	else
		return (b * (LL)bigmod(b, w - 1, p)) % p;
}//bigmod

int odwp(int g)
{
	return bigmod(g, MOD - 2, MOD);
}

// sortuj po indeksie, poczatku przed koncem, dlugosci - dluzsze przed krotszymi
pair < pair<int, bool>, pair<int, int>> events[2 * MR];

int badWays[MR];

bool czyZgodne(int beg1, int dl, int wsk1, int wsk2)
{
	// porownaj hasze na obu slowach
	int pos2 = beg1 - t[wsk2].first;
	// pos1 == 0
	int h1 = (t[wsk1].second.first.front() - (t[wsk1].second.first[dl] * (LL)potP[dl]) % q + q) % q;
	int h2 = (t[wsk2].second.first[pos2] - (t[wsk2].second.first[pos2 + dl] * (LL)potP[dl]) % q + q) % q;
	if (h1 != h2)
		return 0;

	// spr 10 symboli na wszelki wypadek
	REP(i, 10)
	{
		int check = rand() % dl;
		if (t[wsk1].second.second[check] != t[wsk2].second.second[pos2 + check])
			return 0;
	}

	// wyglada na to, ze slowa sa takie same

	return 1;
}

vector < pair< int, int > > zgodne[MR];

bool removed[MR];

int pot2[MR], odw2[MR];

int main()
{
	ios_base::sync_with_stdio(0);

	int n;
	cin >> n;

	potP[0] = pot2[0] = odw2[0] = 1;
	int odw21 = odwp(2);
	FORQ(i, 1, n)
	{
		potP[i] = (potP[i - 1] * (LL)p) % q;
		pot2[i] = (pot2[i - 1] * 2) % MOD;
		odw2[i] = (odw2[i - 1] * (LL)odw21) % MOD;
	}

	string line;
	getline(cin, line);
	getline(cin, line);

	int k = parseLine(line);

	// prepare events
	int ile = 0;
	REP(i, k)
	{
		// poczatki przed koncami, dluzsze przed krotszymi
		events[ile++] = MP(MP(t[i].first, 0), MP(-(int)t[i].second.second.length(), i));
		events[ile++] = MP(MP(t[i].first + t[i].second.second.length() - 1, 1), MP(-(int)t[i].second.second.length(), i));
	}

	sort(events, events + ile);

	// wyznacz klauzule, ktore pokrywaja inne w calosci i je wywal
	// dodatkowo wyznacz, ktore klauzule przecinaja sie zgodnie, potem je odwiedzisz
	// ktore klauzule sa aktualnie otwarte
	vector<int> open;
	REP(i, ile)
	{
		if (events[i].first.second)
		{
			// jesli jest koniec, usun klauzule z otwartych - mozna to zrobic liniowo
			REP(j, open.size())
				if (open[j] == events[i].second.second)
				{
					swap(open.back(), open[j]);
					open.pop_back();
					break;
				}
		}
		else
		{
			int wsk = events[i].second.second;
			// dlugosc klauzuli
			int dl = t[wsk].second.second.length();

			// jedz po wszystkich open i wyznacz te, ktore tna zgodnie
			REP(j, open.size())
			{
				int endOpen = t[open[j]].first + t[open[j]].second.second.length();
				int ned = min(t[wsk].first + dl, endOpen);
				bool sprZgodne = czyZgodne(t[wsk].first, ned - t[wsk].first, wsk, open[j]);
				if (sprZgodne)
				{
					// spr czy open pokrywa aktualna klauzule
					if (endOpen >= t[wsk].first + dl)
						removed[open[j]] = 1;
					else
					{
						// dodaj zgodna klauzule oraz dlugosc sufiksu aktualnej
						zgodne[wsk].push_back(MP(open[j], t[wsk].first + dl - ned));
					}
				}
			}

			// i dodaj ja do open
			open.push_back(wsk);
		}
	}

	// prepare events again, this time without removed clauses
	ile = 0;
	REP(i, k)
		if (!removed[i])
		{
			// poczatki przed koncami, dluzsze przed krotszymi
			events[ile++] = MP(MP(t[i].first, 0), MP(-(int)t[i].second.second.length(), i));
			events[ile++] = MP(MP(t[i].first + t[i].second.second.length() - 1, 1), MP(-(int)t[i].second.second.length(), i));
		}

	sort(events, events + ile);

	// wylicz zle wartosciowania
	int res = 0;
	REP(i, ile)
	{
		if (events[i].first.second)
		{
			// jesli jest koniec, dodaj aktualne sposoby do dotychczasowego wyniku
			res = (res + badWays[events[i].second.second]) % MOD;

			// i usun klauzule z otwartych - mozesz to zrobic liniowo
			REP(j,open.size())
				if (open[j] == events[i].second.second)
				{
					swap(open.back(), open[j]);
					open.pop_back();
					break;
				}
		}
		else
		{
			// wyliczaj badWays dla nowo otwartej klauzuli
			int wsk = events[i].second.second;
			// dlugosc klauzuli
			int dl = t[wsk].second.second.length();

			// ustaw zle wartosciowanie i policz reszta
			badWays[wsk] = pot2[n - dl];

			// odejmij poprzednio wyliczone sposoby, ktore zawieraly ta klauzule zle powartosciowana
			int pom = (res * (LL)odw2[dl]) % MOD;
			badWays[wsk] = (badWays[wsk] - pom + MOD) % MOD;

			// jedz po wszystkich zgodnych i wydzielaj ich sposoby przez sufix
			REP(j, zgodne[wsk].size())
			{
				pom = (badWays[zgodne[wsk][j].first] * (LL)odw2[zgodne[wsk][j].second]) % MOD;
				badWays[wsk] = (badWays[wsk] - pom + MOD) % MOD;
			}

			// i dodaj ja do open
			open.push_back(wsk);
		}
	}

	cout << (pot2[n] - res + MOD) % MOD << "\n";

	cout.flush(); _Exit(0);
}