#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>
#include <chrono>
#include<unordered_map>
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 ALL(u) (u).begin(),(u).end()

#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

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

const int MR = 1e4 + 10;
const int MOD = 1e9 + 7;

char s[MR];
int pot[MR], sil[MR];

int dp[2][MR];

int go1(int n, int r)
{
	int bad = 0;
	dp[0][0] = 1;
	bool sel = 0;
	FORQ(i, 1, n)
	{
		sel = !sel;
		memset(dp[sel], 0, sizeof(dp[sel]));
		int e = min(r, i - 1);
		FORQ(j, 0, e)
		{
			dp[sel][j] = (dp[sel][j] + dp[!sel][j]) % MOD;
			dp[sel][j + 1] = (dp[sel][j + 1] + dp[!sel][j]) % MOD;
		}

		bad = (bad + dp[sel][r + 1] * (LL)pot[n - i]) % MOD;
	}

	return bad;
}

LL modPow(LL a, LL x, LL p) {
	// return a^x mod p
	LL res = 1;
	while (x > 0) {
		if (x & 1) res = (res*a) % p;
		a = (a*a) % p;
		x >>= 1;
	}

	return res;
}

LL modInverse(LL a, LL p) {
	// return modular multiplicative of: a mod p, assuming p is prime
	return modPow(a, p - 2, p);
}

int cnk[MR][MR];

int main()
{
	int n;
	scanf("%d", &n);

	pot[0] = sil[0] = 1;
	FORQ(i, 1, n)
	{
		pot[i] = pot[i - 1] * 2 % MOD;
		sil[i] = sil[i - 1] * (LL)i % MOD;
	}

	set<pair<int, string>> S;
	REP(i, 3)
	{
		int r;
		scanf("%d%s", &r, s);
		S.insert(MP(r, string(s)));
	}

	vector<pair<int, string>> V;
	for (const auto &p : S)
		V.push_back(p);

	int bad = 0;
	if (V.size() == 1)
	{
		// najprostsza sytuacja stan to jest tylko jedna liczba
		bad = go1(n, V.front().first);
	}
	else if (V.size() == 2)
	{
		// wylicz ile jest wspolnych
		int wspolne = 0;
		REP(i, n)
			wspolne += V.front().second[i] == V.back().second[i];

		int rozne = n - wspolne, last = wspolne & 1;
		bad = go1(wspolne, V.back().first)*(LL)pot[rozne] % MOD;

		// wysumuj ostatnie wartosci sufiksowo
		FORD(i, V.back().first, 0)
			dp[last][i] = (dp[last][i] + dp[last][i + 1]) % MOD;

		// rozne zwiekszaja albo jeden albo drugi -> i wyznacza nam, ile razy zwiekszamy pierwszy
		FORQ(i, 0, rozne)
		{
			// wyznacz max roznice
			int df = max(V.front().first - i + 1, V.back().first - (rozne - i) + 1);

			if (df <= V.back().first)
			{
				// mamy dobry podzial na i oraz rozne-i, wez wszystkie podzbiory i-elementowe z rozne
				int newton = sil[rozne] * modInverse(sil[i] * (LL)sil[rozne - i] % MOD, MOD) % MOD;
				bad = (bad + dp[last][df] * (LL)newton) % MOD;
			}
		}
	}
	else
	{
		FORQ(i, 0, n)FORQ(j, 0, i)
			if (j == 0 || j == i)
				cnk[i][j] = 1;
			else
				cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;

		// wyznacz stan wszystkich pol
		// 0 - takie same we 3
		// 1 - inne dla pierwszego slowa, takie samo dla 2 i 3 (zwieksza blad dla 1 lub dla (2,3)
		// 2 - analogicznie tylko dla 2
		// 3

		//auto st = clock();

		vector<int> ile(4, 0);
		REP(i, n)
			if (V[0].second[i] == V[1].second[i] && V[1].second[i] == V[2].second[i])
				ile[0]++;
			else if (V[0].second[i] != V[1].second[i] && V[1].second[i] == V[2].second[i])
				ile[1]++;
			else if (V[0].second[i] == V[2].second[i] && V[0].second[i] != V[1].second[i])
				ile[2]++;
			else
				ile[3]++;

		bad = go1(ile[0], V[2].first)*(LL)pot[n - ile[0]] % MOD;
		int last = ile[0] & 1;

		// wysumuj ostatnie wartosci sufiksowo
		FORD(i, V[2].first, 0)
			dp[last][i] = (dp[last][i] + dp[last][i + 1]) % MOD;

		// znajdz ostatnia niezerowa wartosc wsrod wspolnych
		int lim = 0;
		FORQ(i, 1, V[2].first)
			if (dp[last][i])
				lim = i;

		FORQ(i, 0, ile[1])
		{
			int newton1 = cnk[ile[1]][i];

			FORQ(j, 0, ile[2])
			{
				int newton2 = newton1 * (LL)cnk[ile[2]][j] % MOD;

				// wylicz l1, l2 i l3 -> ile bledow dla kazdego slowa wygenerowalismy
				int l1 = i + (ile[2] - j) + ile[3],
					l2 = j + (ile[1] - i) + ile[3],
					l3 = (ile[1] - i) + (ile[2] - j);

				// wyznacz poczatek przedzialu, dla ktorego l3 daje odp roznice
				int b = max(0, V[2].first + 1 - l3 - lim);
				l1 -= b;
				l2 -= b;
				l3 += b;

				// wyznacz koniec przedzialu, dla ktorego l1 i l2 daja odp roznice
				int e = min(ile[3], b + min(l2 + lim - (V[1].first + 1), l1 + lim - (V[0].first + 1)));

				FORQ(k, b, e)
				{
					// wyznacz maksymalna roznice, gdzie brakuje najwiecej i od tego miejsca w czesci wspolnej bierz dp
					vector<int> tmp{ l1,l2,l3 };

					int df = 0;
					REP(l, 3)
						df = max(df, V[l].first + 1 - tmp[l]);
					// przedzial jest tak wyznaczony, ze df na pewno bedzie ok

					// bierz od df w gore wszystkie wartosci -> wysumowane sufiksowo

					// wylicz wszystkie sposoby
					int newton3 = newton2 * (LL)cnk[ile[3]][k] % MOD;
					bad = (bad + dp[last][df] * (LL)newton3) % MOD;

					l1--;
					l2--;
					l3++;
				}
			}

		}

		//printf("%d\n", clock() - st);
	}

	printf("%d\n", (pot[n] - bad + MOD) % MOD);

	return 0;
}

// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++

//#include <Processthreadsapi.h>
//#include <iostream>
//#include <Synchapi.h>
//#include <windows.h>
//#include <process.h>
//
//DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
//    main2(nullptr);
//    return 0;
//}
//int main() {
//    auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr, STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr);
//    WaitForSingleObject(h, INFINITE);
//}