#pragma GCC optimize ("O3")
#pragma GCC target ("avx")

#include <cstdio>
#include <cassert>
#include <cmath>
#include <cstring>

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <stack>
#include <queue>

#include <tuple>

#define getchar getchar_unlocked
#define putchar putchar_unlocked

#define _rep(_1, _2, _3, _4, name, ...) name
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, c) for (int i = int(a); i < int(b); i += int(c))
#define rep(...) _rep(__VA_ARGS__, rep4, rep3, rep2, _)(__VA_ARGS__)

using namespace std;

using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f80 = long double;

int get_int()
{
    int c, n;

    while ((c = getchar()) < '0');

    n = c - '0';

    while ((c = getchar()) >= '0')
        n = n * 10 + (c - '0');

    return n;
}

const int K = 10;
const int mod = 1e9 + 7;
const i64 lmod = i64(mod) << 32;
const int signs[2] = {1, mod - 1};
int invs[K + 2], binom[K + 2][K + 2], B[K + 1], polys[K + 1][K + 2];

int add(int a, int b)
{
    return (a += b - mod) < 0 ? a + mod : a;
}

i64 add64(i64 a, i64 b)
{
    return (a += b - lmod) < 0 ? a + lmod : a;
}

int mul(int a, int b)
{
    return i64(a) * b % mod;
}

int power_sum(int e, int x)
{
    int ret = 0;

    for (int i = 0; i < e + 2; ++i)
        ret = add(mul(ret, x), polys[e][i]);

    return mul(ret, invs[e + 1]);
}

void init()
{
    invs[0] = invs[1] = 1;

    for (int i = 2; i <= K + 1; ++i)
        invs[i] = mul(invs[mod % i], mod - mod / i);

    for (int i = 0; i <= K + 1; ++i)
    {
        binom[i][0] = 1;

        for (int j = 1; j <= i; ++j)
            binom[i][j] = add(binom[i - 1][j - 1], binom[i - 1][j]);
    }

    B[0] = 1;

    for (int i = 1; i <= K; ++i)
    {
        int s = 0;

        for (int j = 0; j < i; ++j)
            s = add(s, mul(binom[i + 1][j], B[j]));

        B[i] = mul(mul(s, invs[i + 1]), signs[1]);
    }

    for (int i = 0; i <= K; ++i)
    {
        for (int j = 0; j <= i; ++j)
            polys[i][j] = mul(mul(binom[i + 1][j], B[j]), signs[j & 1]);

        polys[i][i + 1] = 0;
    }

    polys[0][1] = 1;
}

int scary_sum(int N, int a, int b, int c, int e1, int e2)
{
    assert(N >= 0);
    assert(a >= 0);
    assert(b >= 0);
    assert(c >= 1);
    assert(e1 + e2 <= K);

    using T = tuple<int, int, int, int>;
    stack<T> stac;

    while (1)
    {
        stac.emplace(N, a, b, c);

        if (N < 0 || a == 0)
            break;

        if (a >= c)
        {
            a %= c;
        }
        else if (b >= c)
        {
            b %= c;
        }
        else
        {
            N = (i64(a) * N + b) / c - 1;
            b = c - 1 - b;
            swap(a, c);
        }
    }

    const int S = e1 + e2;
    static int curr[K + 1][K + 1] = {}, next[K + 1][K + 1] = {};

    while (!stac.empty())
    {
        tie(N, a, b, c) = stac.top();
        stac.pop();

        if (N < 0)
        {
            ;
        }
        else if (a == 0)
        {
            int q = b / c;

            for (int e1 = 0; e1 <= S; ++e1)
            {
                int s = power_sum(e1, N);

                for (int e2 = 0; e2 <= S - e1; ++e2)
                    next[e1][e2] = s, s = mul(s, q);
            }
        }
        else if (a >= c || b >= c)
        {
            int q = (a >= c) ? a / c : b / c;
            int d = (a >= c) ? 1 : 0;

            for (int e1 = 0; e1 <= S; ++e1)
            {
                for (int e2 = 0; e2 <= S - e1; ++e2)
                {
                    i64 s = 0;
                    int p = 1;

                    for (int i2 = 0; i2 <= e2; ++i2)
                    {
                        s = add64(s, i64(p) * mul(binom[e2][i2], curr[e1 + i2 * d][e2 - i2]));
                        p = mul(p, q);
                    }

                    next[e1][e2] = s % mod;
                }
            }
        }
        else
        {
            static int cumu[K + 1][K + 1];

            for (int e2 = 0; e2 <= S - 1; ++e2)
            {
                for (int e1 = 0; e1 <= S - e2 - 1; ++e1)
                {
                    i64 s = 0;

                    for (int j = 0; j <= e1 + 1; ++j)
                    {
                        s = add64(s, i64(polys[e1][e1 + 1 - j]) * curr[e2][j]);
                    }

                    cumu[e1][e2] = mul(s % mod, invs[e1 + 1]);
                }
            }

            const int M = (i64(a) * N + b) / c;

            for (int e1 = 0; e1 <= S; ++e1)
            {
                int p = power_sum(e1, N);

                for (int e2 = 0; e2 <= S - e1; ++e2)
                {
                    i64 t = 0;

                    for (int i2 = 0; i2 < e2; ++i2)
                    {
                        t = add64(t, i64(cumu[e1][i2]) * binom[e2][i2]);
                    }

                    next[e1][e2] = add(p, mod - t % mod);
                    p = mul(p, M);
                }
            }
        }

        swap(curr, next);
    }

    return curr[e1][e2];
}

void solve()
{
    init();
    int T = get_int();
    rep(_, T)
    {
        int N = get_int(), a = get_int(), b = get_int(), c = get_int();
        int e1 = get_int(), e2 = get_int();
        printf("%d\n", scary_sum(N, a, b, c, e1, e2));
    }
}

int main()
{
    clock_t beg = clock();
    solve();
    clock_t end = clock();
    fprintf(stderr, "%.3f sec\n", double(end - beg) / CLOCKS_PER_SEC);
    return 0;
}