#include <bits/stdc++.h>
using namespace std;
#define debug(fmt, ...) \
  fprintf(stderr, "[%d] " fmt "\n", __LINE__, ##__VA_ARGS__)
template <class _Tx, class _Ty>
inline void chkmin(_Tx& x, const _Ty& y) {
  x = min<common_type_t<_Tx, _Ty>>(x, y);
}
template <class _Tx, class _Ty>
inline void chkmax(_Tx& x, const _Ty& y) {
  x = max<common_type_t<_Tx, _Ty>>(x, y);
}
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
bool Mbe;
namespace euclid {
template <class _Tp>
_Tp qpow(_Tp x, ll y) {
  _Tp ret;
  for (; y; y >>= 1, x = x * x) if (y & 1) ret = ret * x;
  return ret;
}
template <class _Tp>
_Tp euclid_impl(ll a, ll b, ll c, ll n, const _Tp& U, const _Tp& R) {
  ll m = ((i128)a * n + c) / b;
  if (!m) return qpow(R, n);
  return qpow(R, (b - c - 1) / a) * U *
         euclid_impl(b % a, a, (b - c - 1) % a, m - 1, R, qpow(R, b / a) * U) *
         qpow(R, n - ((i128)b * m - c - 1) / a);
}
template <class _Tp>
_Tp euclid(ll a, ll b, ll c, ll n, const _Tp& U, const _Tp& R) {
  return qpow(U, c / b) * euclid_impl(a % b, b, c % b, n, U, qpow(U, a / b) * R);
}
} // namespace euclid
constexpr int K = 11, mod = 1e9 + 7;
int kx, ky, bnm[K][K];
ll n, a, b, c;
inline void add(int& x, int y) { x += y, x >= mod && (x -= mod); }
int qpow(int x, int y) {
  int ret = 1;
  for (; y; y >>= 1, x = (ll)x * x % mod)
    if (y & 1) ret = (ll)ret * x % mod;
  return ret;
}
struct node {
  int val[K][K], sum[K][K];
  node() {
    memset(val, 0, sizeof(val));
    memset(sum, 0, sizeof(sum));
    val[0][0] = 1;
  }
};
node operator*(const node& lhs, const node& rhs) {
  node ret;
  ret.val[0][0] = 0;
  for (int i = 0; i <= kx; ++i) {
    for (int j = 0; j <= ky; ++j) {
      ret.sum[i][j] = lhs.sum[i][j];
    }
  }
  for (int i = 0; i <= kx; ++i) {
    for (int j = 0; i + j <= kx; ++j) {
      for (int k = 0; k <= ky; ++k) {
        for (int l = 0; k + l <= ky; ++l) {
          add(ret.val[i + j][k + l], (ll)lhs.val[i][k] * rhs.val[j][l] % mod *
                                         bnm[i + j][i] % mod *
                                         bnm[k + l][k] % mod);
          add(ret.sum[i + j][k + l], (ll)lhs.val[i][k] * rhs.sum[j][l] % mod *
                                         bnm[i + j][i] % mod *
                                         bnm[k + l][k] % mod);
        }
      }
    }
  }
  return ret;
}
void mian() {
  cin >> n >> a >> c >> b >> kx >> ky;
  node U, R;
  for (int i = 0; i <= kx; ++i) {
    for (int j = 0; j <= ky; ++j) {
      U.val[i][j] = !i;
      U.sum[i][j] = 0;
      R.val[i][j] = !j;
      R.sum[i][j] = !j;
    }
  }
  int ans = (ll)qpow(0, kx) * qpow(c / b % mod, ky) % mod;
  add(ans, euclid::euclid<node>(a, b, c, n, U, R).sum[kx][ky]);
  cout << ans << '\n';
}
bool Med;
int main() {
  // debug("Mem: %.4lfMB.", fabs(&Med - &Mbe) / 1048576);
  cin.tie(0)->sync_with_stdio(0);
  int cas;
  cin >> cas;
  for (int i = 0; i < K; ++i) {
    bnm[i][0] = bnm[i][i] = 1;
    for (int j = 1; j < i; ++j) add(bnm[i][j] = bnm[i - 1][j - 1], bnm[i - 1][j]);
  }
  while (cas--) mian();
  return 0;
}
/*
g++ -std=c++14 -O2 -o qoj-273 qoj-273.cpp -Wall -Wextra
-Wshadow -fsanitize=address,undefined -g
*/