#include <iostream>
#include <cstring>
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
#include <map>
using namespace std;

typedef long long ll;
const ll MODULO = 1e9 + 7;
const int MAXDIMENSION = 1e4;
typedef map<int, map<int, map<int, map<int, ll> >  > > Flexi4dArray;
//#define DEBUG

class Math
{
public:
	Math()
	{
		InitializeFactorials();
		InitializeModularInversions();
	}

	ll Factorial(int n)
	{
		return factorials[n];
	}

	ll ModularInversionOfGivenFactorial(int n)
	{
		return modularInversionsOfFactorials[n];
	}

	ll GetModularBinomialCoeff(ll n, ll k)
	{
		if (k > n)
			return 0;
		if (k == n || k == 0)
			return 1;
		const ll inv1 = ModularInversionOfGivenFactorial(k);
		const ll inv2 = ModularInversionOfGivenFactorial(n - k);
		const ll fact = Factorial(n);
		const ll result = (((fact * inv1) % MODULO) * inv2) % MODULO;

		return result;
	}
private:
	void InitializeFactorials()
	{
		factorials[0] = factorials[1] = 1;
		for (ll i = 2; i <= MAXDIMENSION; ++i)
			factorials[i] = (factorials[i - 1] * i) % MODULO;
	}

	void InitializeModularInversions()
	{
		for (int n = 1; n <= MAXDIMENSION; ++n)
		{
			ll numberToInvert = factorials[n];
			modularInversionsOfFactorials[n] = GetModularInversion(numberToInvert);

			if ((numberToInvert * modularInversionsOfFactorials[n]) % MODULO != 1)
				throw string("Unexpeceted issue - wrong inversion");
		}
	}

	static ll GetModularInversion(ll a)
	{
		ll x, y;
		ll gcd = GcdExtended(a, MODULO, &x, &y);
		if (gcd != 1)
			throw string("Unexpeced issue - gcd doesn't exist");

		return (x + MODULO) % MODULO;
	}

	static ll GcdExtended(ll a, ll b, ll *x, ll *y)
	{
		if (a == 0)
		{
			*x = 0, *y = 1;
			return b;
		}

		ll x1, y1;
		ll gcd = GcdExtended(b%a, a, &x1, &y1);

		*x = y1 - (b / a) * x1;
		*y = x1;

		return gcd;
	}

	ll factorials[10000 + 1];
	ll modularInversionsOfFactorials[10000 + 1];
};

Math math;

int BinaryStringToInt(const string& s)
{
	int result = 0;
	for (int pow = 0, i = s.size() - 1; i >= 0; --i, ++pow)
		result += (1 << pow) * (s[i] - '0');

	return result;
}

string ToBinaryString(int number, int dimension)
{
	string result;
	while (number > 0)
	{
		if (number % 2 == 0)
			result.push_back('0');
		else
			result.push_back('1');

		number /= 2;
	}
	while (result.size() < dimension)
		result.push_back('0');

	reverse(result.begin(), result.end());
	return result;
}

struct Sphere
{
	Sphere(){}
	Sphere(int r, string c) : radius(r), center(c) {}
	int radius;
	string center;

	int GetCenter() const
	{
		return BinaryStringToInt(center);
	}

	int GetNumberOfDifferences(const string& otherCenter) const
	{
		if (otherCenter.size() != center.size())
			throw string("Wtf");

		int result = 0;
		for (int i = 0; i < center.size(); ++i)
			result += (center[i] != otherCenter[i]);

		return result;
	}
};

typedef vector<Sphere> Spheres;
Spheres CreateSpheres(int r1, string c1, int r2, string c2, int r3, string c3)
{
	return Spheres{ Sphere(r1, c1), Sphere(r2, c2), Sphere(r3, c3) };
}

struct ISolver
{
	virtual ll Solve(int dimension, Spheres spheres) = 0;
};

static int GetNmberOfDifferentBits(int firstNumber, int secondNumber, int dimension)
{
	int result = 0;

	for (int i = 0; i < dimension; i++)
	{
		if (((firstNumber >> i) & 1) != ((secondNumber >> i) & 1))
			result++;
	}

	return result;
}

class SimpleSolver: public ISolver
{
public:
	ll Solve(int dimension, Spheres spheres)
	{
		ll result = 0;
		for (int candidate = 0; candidate < (1 << dimension); ++candidate)
		{
			for (const Sphere& sphere : spheres)
			{
				if (GetNmberOfDifferentBits(candidate, sphere.GetCenter(), dimension) <= sphere.radius)
				{
					result = (result + 1) % MODULO;
					break;
				}
			}
		}

		return result;
	}
	
};


class SmartSolver : public ISolver
{
public:
	ll Solve(int dimension, Spheres spheres)
	{
		this->dimension = dimension;
		ll result = GetSingleSum(spheres, dimension);
		
		for (int i = 0; i < spheres.size(); ++i)
		{
			for (int j = i + 1; j < spheres.size(); ++j)
				result = (result + (MODULO - GetNumberOfCommonStrings(spheres[i], spheres[j]))) % MODULO;
		}

		result = (result + GetNumberOfCommonStrings(spheres[0], spheres[1], spheres[2])) % MODULO;


		return result;
	}
	
	static ll GetNumberOfCommonStrings(const Sphere& firstSphere, const Sphere& secondSphere)
	{
		const int dimension = firstSphere.center.size();
		if (firstSphere.center == secondSphere.center)
		{
			int minRadius = min(firstSphere.radius, secondSphere.radius);
			return GetNumberOfStringWichDiffersOnAtMostGivenBits(minRadius, dimension);
		}
		else
		{
			int numberOfDifferentBits = firstSphere.GetNumberOfDifferences(secondSphere.center);
			ll result = 0;
			if (numberOfDifferentBits > firstSphere.radius + secondSphere.radius)
				return result;

			for (int r1 = 0; r1 <= min(firstSphere.radius, numberOfDifferentBits); r1++)
			{
				for (int r2 = numberOfDifferentBits - r1; r2 <= min(secondSphere.radius, numberOfDifferentBits); ++r2)
				{
					if (r1 + r2 != numberOfDifferentBits)
						continue;
					int minLeftRadius = min(min(firstSphere.radius - r1, secondSphere.radius - r2), dimension - numberOfDifferentBits);
					result += math.GetModularBinomialCoeff(numberOfDifferentBits, r1) 
						* (dimension > numberOfDifferentBits ? GetNumberOfStringWichDiffersOnAtMostGivenBits(minLeftRadius, dimension - numberOfDifferentBits) : 1);
					result %= MODULO;
				}
			}

			return result;
		}
	}

	static ll GetNumberOfCommonStrings(const Sphere& firstSphere, const Sphere& secondSphere, const Sphere& thirdSphere)
	{
		return GetNumberOfCommonStrings(Spheres{ firstSphere, secondSphere, thirdSphere });
	}

	

private:
	static ll GetNumberOfStringWhichDiffersOnGivenBits(int targetBitsDifference, int dimension)
	{
		return math.GetModularBinomialCoeff(dimension, targetBitsDifference);
	}

	static ll GetNumberOfStringWichDiffersOnAtMostGivenBits(int targetBitsDifference, int dimension)
	{
		ll result = 0;
		for (int difference = 0; difference <= targetBitsDifference; ++difference)
			result = (result + GetNumberOfStringWhichDiffersOnGivenBits(difference, dimension)) % MODULO;

		return result;
	}

	static ll GetSingleSum(const Spheres& spheres, int dimension)
	{
		ll result = 0;
		for (const Sphere& s : spheres)
			result = (result + GetNumberOfStringWichDiffersOnAtMostGivenBits(s.radius, dimension)) % MODULO;

		return result;
	}

	static ll GetNumberOfCommonStrings(const Spheres& spheres)
	{
		differenecs = CreateDifferencesVector(spheres);
		staticDim = spheres[0].center.size();
		storedValues.clear();

		return CalculateNumberOfCommons(0, spheres[0].radius, spheres[1].radius, spheres[2].radius);
	}

	static ll CalculateNumberOfCommons(int currentDifference, int r1, int r2, int r3)
	{
		if (r1 < 0 || r2 < 0 || r3 < 0)
			throw string("What");
		map<int, ll>::iterator it = storedValues[currentDifference][r1][r2].find(r3);
		if (it != storedValues[currentDifference][r1][r2].end())
			return it->second;

		if (r1 == 0 && r2 == 0 && r3 == 0 && currentDifference < differenecs.size())
		{
			return storedValues[currentDifference][r1][r2][r3] = 0;
		}

		if (currentDifference == differenecs.size())
		{
			int minRadius = min(r1, min(r2, r3));
			if (minRadius < 0) return 0;
			return GetNumberOfStringWichDiffersOnAtMostGivenBits(minRadius, staticDim - differenecs.size());
		}

		ll res = 0;
		switch (differenecs[currentDifference])
		{
		case 1:
		case 6:
			res = (r3 > 0 ? CalculateNumberOfCommons(currentDifference + 1, r1, r2, r3 - 1) : 0) 
				+ (r1 > 0 && r2 > 0 ?CalculateNumberOfCommons(currentDifference + 1, r1 - 1, r2 - 1, r3) : 0);
			break;
		case 2:
		case 5:
			res = (r1 > 0 && r3 >0 ? CalculateNumberOfCommons(currentDifference + 1, r1 - 1, r2, r3 - 1) : 0) 
				+ (r2 > 0 ? CalculateNumberOfCommons(currentDifference + 1, r1, r2 - 1, r3) : 0);
			break;
		case 3:
		case 4:
			res = (r2 > 0 && r3 > 0 ? CalculateNumberOfCommons(currentDifference + 1, r1, r2 - 1, r3 - 1) : 0)
				+ (r1 > 0 ? CalculateNumberOfCommons(currentDifference + 1, r1 - 1, r2, r3) : 0);
			break;
		}
		res %= MODULO;

		return storedValues[currentDifference][r1][r2][r3] = res;
	}

	static vector<int> CreateDifferencesVector(const Spheres& spheres)
	{
		vector<int> result;
		for (int len = 0; len < spheres[0].center.size(); ++len)
		{
			int diffType = (spheres[0].center[len] - '0') * 4 + (spheres[1].center[len] - '0') * 2
				+ (spheres[2].center[len] - '0');

			if (diffType == 0 || diffType == 7)
				continue;

			result.push_back(diffType);
		}

		return result;
	}

	static vector<int> differenecs;
	static Flexi4dArray storedValues;
	static int staticDim;
	int dimension;
};

vector<int> SmartSolver::differenecs;
Flexi4dArray SmartSolver::storedValues;
int SmartSolver::staticDim;

class AllPosibilitesTester
{
public:
	AllPosibilitesTester(ISolver* s1, ISolver* s2)
		: firstSolver(s1), secondSolver(s2)
	{
	}

	void Test()
	{
		for (int dimension = 1; dimension <= 5; ++dimension)
		{
			vector<int> allPossibleCenters = GenerateAllPossibleCenters(dimension);
			Spheres spheres = GenerateAllPossibleSpheres(allPossibleCenters, dimension);
			for (const Sphere& s1: spheres)
			{
				for (const Sphere& s2 : spheres)
				{
					for (const Sphere& s3 : spheres)
					{
						Spheres input{ s1, s2, s3 };
						ll r1 = firstSolver->Solve(dimension, input);
						ll r2 = secondSolver->Solve(dimension, input);

						if (r1 != r2)
						{
							cout << "Ups! First solver: " << r1 << ", second solver: " << r2 << "\n";
						}
					}
				}
			}
		}
	}

private:
	vector<int> GenerateAllPossibleCenters(int dimension)
	{
		vector<int> result;
		for (int i = 0; i < (1 << dimension); ++i)
			result.push_back(i);

		return result;
	}

	Spheres GenerateAllPossibleSpheres(const vector<int>& allPossibleCenters, int dimension)
	{
		Spheres result;
		for (int d = 0; d <= dimension; ++d)
		{
			for (int center : allPossibleCenters)
				result.push_back(Sphere(d, ToBinaryString(center, dimension)));
		}

		return result;
	}

	ISolver* firstSolver;
	ISolver* secondSolver;
};

ll ComputeSimpleCommon(const Sphere& s1, const Sphere& s2)
{
	const int dim = s1.center.size();
	int result = 0;
	for (int candidate = 0; candidate < (1 << dim); ++candidate)
	{
		if (GetNmberOfDifferentBits(candidate, s1.GetCenter(), dim) <= s1.radius
			&& GetNmberOfDifferentBits(candidate, s2.GetCenter(), dim) <= s2.radius)
			++result;
	}

	return result;
}

ll ComputeSimpleCommon(const Sphere& s1, const Sphere& s2,  const Sphere& s3)
{
	const int dim = s1.center.size();
	int result = 0;
	for (int candidate = 0; candidate < (1 << dim); ++candidate)
	{
		if (GetNmberOfDifferentBits(candidate, s1.GetCenter(), dim) <= s1.radius
			&& GetNmberOfDifferentBits(candidate, s2.GetCenter(), dim) <= s2.radius
			&& GetNmberOfDifferentBits(candidate, s3.GetCenter(), dim) <= s3.radius)
			++result;
	}

	return result;
}

void Debug()
{
	SimpleSolver simpleSolver;
	SmartSolver smartSolver;

	for (int dim = 1; dim <= 9 * 0; ++dim)
	{
		cout << "dim=" << dim << endl;
		for (int i = 0; i < (1 << dim); ++i)
		{
			for (int j = 0; j < (1 << dim); ++j)
			{
				for (int r1 = 0; r1 <= dim; ++r1)
				{
					for (int r2 = 0; r2 <= dim; ++r2)
					{
						Sphere s1(r1, ToBinaryString(i, dim));
						Sphere s2(r2, ToBinaryString(j, dim));
						ll smartCommon = SmartSolver::GetNumberOfCommonStrings(s1, s2);
						ll simpleCommon = ComputeSimpleCommon(s1, s2);

						if (smartCommon != simpleCommon)
						{
							cout << "Ups2 " << smartCommon << " != " << simpleCommon << "\n";
						}
					}
				}
			}
		}
	}

	for (int dim = 1; dim <= 5 * 0; ++dim)
	{
		for (int i = 0; i < (1 << dim); ++i)
		{
			for (int j = 0; j < (1 << dim); ++j)
			{
				for (int k = 0; k < (1 << dim); ++k)
				{
					for (int r1 = 0; r1 <= dim; ++r1)
					{
						for (int r2 = 0; r2 <= dim; ++r2)
						{
							for (int r3 = 0; r3 <= dim; ++r3)
							{
								Sphere s1(r1, ToBinaryString(i, dim));
								Sphere s2(r2, ToBinaryString(j, dim));
								Sphere s3(r3, ToBinaryString(k, dim));
								ll smartCommon = SmartSolver::GetNumberOfCommonStrings(s1, s2, s3);
								ll simpleCommon = ComputeSimpleCommon(s1, s2, s3);

								if (smartCommon != simpleCommon)
								{
									cout << "Ups3 " << smartCommon << " != " << simpleCommon << "\n";
								}
							}
						}
					}
				}
			}
		}
	}

	assert(simpleSolver.Solve(3, CreateSpheres(1, "000", 1, "100", 0, "111")) == 7);
	assert(simpleSolver.Solve(5, CreateSpheres(2, "10110", 0, "11010", 1, "00000")) == 19);
	assert(math.Factorial(1) == 1);
	assert(math.Factorial(4) == 24);
	assert(math.Factorial(10) == 3628800);
	for (int n = 1; n <= 100; ++n)
		assert(math.GetModularBinomialCoeff(n, 1) == n);

	for (int n = 1; n <= 100; ++n)
		assert(math.GetModularBinomialCoeff(n, n) == 1);

	for (int n = 2; n <= 100; ++n)
		assert(math.GetModularBinomialCoeff(n, 2) == n * (n-1) / 2);

	AllPosibilitesTester allPosibilitesTester(&simpleSolver, &smartSolver);
	allPosibilitesTester.Test();

	cout << "Debug done\n";
}

struct Input
{
	int dimension;
	Spheres spheres;
};

Input ReadInput()
{
	Input input;
	cin >> input.dimension;
	for (int i = 0; i < 3; ++i)
	{
		Sphere sphere;
		cin >> sphere.radius;
		cin >> sphere.center;
		input.spheres.push_back(sphere);
	}

	return input;
}
int main()
{
	ios::sync_with_stdio(false);
#ifdef DEBUG
	Debug();
#endif
	SmartSolver smartSolver;
	Input input = ReadInput();

	cout << smartSolver.Solve(input.dimension, input.spheres) << "\n";
#ifdef DEBUG
	system("pause");
#endif
}