#include <bits/stdc++.h>
using namespace std;
const int SZE = 1e6 + 10;
class Multiplicative {
 public:
  long long size;
  vector<long long> fn;
  vector<long long> primes;
  vector<long long> lowest_prime_factor;
  Multiplicative(long long sizer) {
    size = sizer;
    lowest_prime_factor = vector<long long>(size, 0);
    fn = vector<long long>(size, 0);
    for (long long i = 2; i < size; i++) lowest_prime_factor[i] = i;
    for (long long i = 2; i < size; i++) {
      if (lowest_prime_factor[i] == i) {
        fn[i] = (-1);
        primes.push_back(i);
      }
      for (auto p : primes) {
        long long ith_multiple = i * p;
        if (ith_multiple >= size) break;
        lowest_prime_factor[ith_multiple] = min(lowest_prime_factor[i], p);
        if (i % p) {
          fn[ith_multiple] = fn[i] * fn[p];
        } else {
          fn[ith_multiple] = (0);
          break;
        }
      }
    }
  }
};
Multiplicative sieve(SZE);
void primeFactorize(int n, map<int, int> &m) {
  while (n > 1) {
    int p = sieve.lowest_prime_factor[n];
    while (n % p == 0) {
      n /= p;
      m[p]++;
    }
  }
}
long long packets = 0;
long long on, om;
void getAllFactorsRecur(const vector<pair<int, int> > &primeFactors,
                        long long curr = 1, int primeIdx = 0) {
  if (primeIdx == primeFactors.size()) {
    packets += curr <= on;
    return;
  }
  long long ans = 1, p = primeFactors[primeIdx].first,
            c = primeFactors[primeIdx].second;
  for (int i = 0; i <= c; i++) {
    getAllFactorsRecur(primeFactors, ans * curr, primeIdx + 1);
    ans *= p;
  }
}
vector<int> input(3);
void takeinputandfactor(int pos, map<int, int> &store, long long &x) {
  cin >> input[0] >> input[1] >> input[2];
  x = 1ll * input[0] * input[1] * input[2];
  if (pos == 2) return;
  for (auto x : input) {
    primeFactorize(x, store);
  }
  if (pos == 3) store[2]++;
  if (pos != 3) return;
  vector<pair<int, int> > fctors;
  fctors.reserve(store.size());
  for (auto f : store) {
    fctors.push_back(f);
  }
  getAllFactorsRecur(fctors);
}
void solve() {
  packets = 0;
  map<int, int> sn, sm, ss;
  long long os;
  takeinputandfactor(1, sn, on);
  takeinputandfactor(2, sm, om);
  takeinputandfactor(3, ss, os);
  int cnt, lim;
  vector<long long> mults, dp;
  long long firstpart;
  if (on == 1) {
    goto end;
  }
  for (auto divisor : sn) {
    auto prime = divisor.first;
    if (ss[prime] < divisor.second) {
      long long p = pow(prime, ss[prime]);
      if (p <= om / prime) mults.push_back(p * prime);
    }
  }
  cnt = mults.size();
  lim = 1 << cnt;
  firstpart = 0;
  assert(cnt <= 15);
  for (int mask = 0; mask < lim; mask++) {
    long long prod = 1;
    int sign = 1;
    for (int i = 0; i < cnt; i++) {
      if (mask & (1 << i)) {
        long long multiplicand = mults[i];
        if (prod > om / multiplicand) goto end2;
        prod *= multiplicand;
        sign = -sign;
      }
    }
    firstpart += (om / prod) * sign;
  end2:;
  }
  packets += firstpart;
end:
  cout << packets << "\n";
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  int t;
  cin >> t;
  while (t--) solve();
  return 0;
}
