#include <iostream>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
#define lli long long int
#define vi vector<int>
#define vlli vector<lli>
#define vb vector<bool>
#define vvi vector<vi>
#define vvlli vector<vlli>
#define vpii vector<pair<int, int>>
#define str string
#define vs vector<str>
#define vc vector<char>
#define vvc vector<vc>

const lli mod = 1000000007;

lli dist(str s1, str s2)
{
    int d = 0;
    for (int i = 0; i < s1.size(); i++)
        if (s1[i] != s2[i])
            d++;
    return d;
}


str binary_repr(lli a, int fill)
{
    str binary = "";
    int mask = 1;
    for(int i = 0; i < fill; i++)
    {
        if((mask&a) >= 1)
            binary = "1"+binary;
        else
            binary = "0"+binary;
        mask<<=1;
    }
    return binary;
}

bool within(lli r, str s, str x)
{
    return dist(s, x) <= r;
}

lli brutal(lli r1, str s1, lli r2, str s2, lli r3, str s3)
{
    int n = s1.size();
    lli m = pow(2, n);
    lli ans = 0;
    for (int i = 0; i < m; i++)
    {
        str x = binary_repr(i, n);
        if (within(r1, s1, x) || within(r2, s2, x) || within(r3, s3, x))
            ans++;
    }

    return ans;
}

lli n_po_k(vvlli &npk, lli n, lli k)
{
    if (k > (n / 2))
        k = n - k;
    if (npk[n][k] != -1)
        return npk[n][k];
    else
    {
        lli x = n_po_k(npk, n - 1, k) % mod;
        lli y = n_po_k(npk, n - 1, k - 1) % mod;
        npk[n][k] = (x + y) % mod;
        return npk[n][k];
    }
}

lli przeciecie_3()
{
    return 0; // lucky shot ;)
}

lli przeciecie_2(lli r1, str s1, lli r2, str s2, vvlli &npk)
{
    lli d = dist(s1, s2); // odległość środków
    lli ans = 0;
    int n = s1.size();

    // zbliżanie do s1
    int range1 = max(1, (int)(d - r1));
    for (int i = range1; i <= r2; i++)
    {
        int rng1 = min((r2-i)/2, min(d - i, n - d));
        for (int j = 0; j <= rng1; j++)
        {
            ans += (n_po_k(npk, d, i + j) * n_po_k(npk, n - d, j)) % mod;
            ans = ans % mod;
        }
    }

    // oddalanie od s1
    int range2 = min(r2, r1 - d);
    for (int i = 1; i <= range2; i++)
    {
        int rng2 = min((r2-i)/2, min(n - d - i, d));
        for (int j = 0; j <= rng2; j++)
        {
            ans += (n_po_k(npk, n - d, i + j) * n_po_k(npk, d, j)) % mod;
            ans = ans % mod;
        }
    }

    // bez zmiany odległości do s1
    int rng3 = min(r2/2, min(d, n - d));
    if (r1 >= d)
    {
        for (int j = 0; j <= rng3; j++)
        {
            ans += (n_po_k(npk, d, j) * n_po_k(npk, n-d, j)) % mod;
            ans = ans % mod;
        }
    }

    return ans;
}

lli przeciecie_1(lli r, str s, vvlli &npk)
{
    return przeciecie_2(r, s, r, s, npk);
}

lli solve_for_1(lli r, str s, vvlli npk)
{
    lli ans = 0;
    ans += przeciecie_1(r, s, npk);
    return ans;
}

lli solve_for_2(lli r1, str s1, lli r2, str s2, vvlli &npk)
{
    lli ans = 0;
    ans += przeciecie_1(r1, s1, npk);
    ans += przeciecie_1(r2, s2, npk);
    //cout << przeciecie_1(r1, s1, npk) << " " << przeciecie_1(r2, s2, npk) << " " << przeciecie_2(r1, s1, r2, s2, npk) << endl;
    ans = ans % mod;

    if (r1 < r2)
    {
        swap(r1, r2);
        swap(s1, s2);
    }

    ans -= przeciecie_2(r1, s1, r2, s2, npk);
    if (ans < 0)
        ans = mod + ans;
    ans = ans % mod;

    return ans;
}

lli solve_for_3(lli r1, str s1, lli r2, str s2, lli r3, str s3, vvlli &npk)
{
    int d12, d23, d31;
    d12 = dist(s1, s2);
    d23 = dist(s2, s3);
    d31 = dist(s3, s1);

    //cout << s1 << " " << s2 << " " << s3 << " "<< d12 << " " << d23 << " " << d31 << " : ";

    if (d12 + r1 <= r2)
        return solve_for_2(r2, s2, r3, s3, npk);
    if (d12 + r2 <= r1)
        return solve_for_2(r1, s1, r3, s3, npk);
    if (d23 + r2 <= r3)
        return solve_for_2(r1, s1, r3, s3, npk);
    if (d23 + r3 <= r2)
        return solve_for_2(r1, s1, r2, s2, npk);
    if (d31 + r1 <= r3)
        return solve_for_2(r2, s2, r3, s3, npk);
    if (d31 + r3 <= r1)
        return solve_for_2(r1, s1, r2, s2, npk);
    if (s1.size() <= 20)
        return brutal(r1, s1, r2, s2, r3, s3);

    lli ans = 0;
    ans += przeciecie_1(r1, s1, npk);
    ans += przeciecie_1(r2, s2, npk);
    ans = ans % mod;
    ans += przeciecie_1(r3, s3, npk);
    ans = ans % mod;

    if (r1 < r2)
    {
        swap(r1, r2);
        swap(s1, s2);
    }
    if (r1 < r3)
    {
        swap(r2, r3);
        swap(s2, s3);
        swap(r2, r1);
        swap(s2, s1);
    }
    if (r3 > r2)
    {
        swap(r2, r3);
        swap(s2, s3);
    }

    ans -= przeciecie_2(r1, s1, r2, s2, npk);
    if (ans < 0)
        ans = mod + ans;
    ans = ans % mod;
    ans -= przeciecie_2(r1, s1, r3, s3, npk);
    if (ans < 0)
        ans = mod + ans;
    ans = ans % mod;
    ans -= przeciecie_2(r2, s2, r3, s3, npk);
    if (ans < 0)
        ans = mod + ans;
    ans = ans % mod;

    ans += przeciecie_3();
    ans = ans % mod;
    return ans;
}



int main()
{
    lli n;
    cin >> n;
    // n po k przygotowania
    vvlli npk(n + 1);
    for (int i = 0; i <= n; i++)
    {
        npk[i] = vlli((i / 2) + 1, -1);
        npk[i][0] = 1;
    }

    lli r1, r2, r3; // promienie
    str s1, s2, s3; // srodki

    cin >> r1 >> s1;
    cin >> r2 >> s2;
    cin >> r3 >> s3;

    if (r1 == r2 && r2 == r3 && s1 == s2 && s2 == s3)
    {
        cout << solve_for_1(r1, s1, npk) << endl;
    }
    else if (r1 == r2 && s1 == s2)
    {
        cout << solve_for_2(r1, s1, r3, s3, npk) << endl;
    }
    else if (r2 == r3 && s2 == s3)
    {
        cout << solve_for_2(r1, s1, r2, s2, npk) << endl;
    }
    else if (r1 == r3 && s1 == s3)
    {
        cout << solve_for_2(r1, s1, r2, s2, npk) << endl;
    }
    else
    {
        cout << solve_for_3(r1, s1, r2, s2, r3, s3, npk) << endl;
    }

    return 0;
}

// for (int i = 0; i <= n; i++) // DEBUG N PO K
// {
//     for (int j = 0; j < npk[i].size(); j++)
//         cout << npk[i][j] << " ";
//     cout << endl;
// }