#include <bits/stdc++.h>
using namespace std;
int divs[1000001];
vector<int> primes;
void prepare() {
  memset(divs, 0, sizeof(divs));
  int p = 2;
  divs[0] = divs[1] = 1;
  divs[2] = 2;
  for (int i = 4; i < 1000001; i += 2) divs[i] = 2;
  primes.push_back(2);
  for (int p = 3; p < 1000001; p += 2) {
    if (!divs[p]) {
      primes.push_back(p);
      divs[p] = p;
      for (int i = p * 2; i < 1000001; i += p) divs[i] = p;
    }
  }
}
inline void genPrime(int n, map<int, int>& m) {
  while (n > 1) m[divs[n]]++, n /= divs[n];
}
vector<pair<int, pair<int, int> > > combinePrimes(
    const map<int, int>& m_primes, const map<int, int>& s_primes) {
  map<int, pair<int, int> > ps;
  auto itm = m_primes.begin(), its = s_primes.begin();
  while (itm != m_primes.end() && its != s_primes.end()) {
    if (itm->first < its->first) {
      ps[itm->first] = make_pair(itm->second, 0);
      itm++;
    } else if (itm->first > its->first) {
      ps[its->first] = make_pair(0, its->second);
      its++;
    } else {
      ps[itm->first] = make_pair(itm->second, its->second);
      itm++;
      its++;
    }
  }
  while (itm != m_primes.end()) {
    ps[itm->first] = make_pair(itm->second, 0);
    itm++;
  }
  while (its != s_primes.end()) {
    ps[its->first] = make_pair(0, its->second);
    its++;
  }
  return vector<pair<int, pair<int, int> > >(ps.rbegin(), ps.rend());
}
long long gcd(long long a, long long b) {
  if (!a || !b) return a + b;
  if (b < a)
    return gcd(b, a % b);
  else
    return gcd(a, b % a);
}
void count_dfs(long long& res, const vector<int>& usedPrimes, long long mx,
               long long prod, int pi, int used) {
  if (prod > mx) return;
  if (pi == usedPrimes.size()) {
    if (used > 0) {
      if (used % 2)
        res += mx / prod;
      else
        res -= mx / prod;
    }
  } else {
    count_dfs(res, usedPrimes, mx, prod, pi + 1, used);
    count_dfs(res, usedPrimes, mx, prod * usedPrimes[pi], pi + 1, used + 1);
  }
}
void count1(long long& res, const vector<int>& usedPrimes, long long mx) {
  long long r = 0;
  count_dfs(r, usedPrimes, mx, 1, 0, 0);
  res += mx - r;
}
void recur(long long& res, const vector<pair<int, pair<int, int> > >& ps,
           vector<int>& cp, int pi, long long prod, long long mx) {
  long long p = ps[pi].first;
  long long pa = ps[pi].second.first;
  long long pb = ps[pi].second.second;
  int maxp = (pa <= pb) ? 0 : pb;
  bool isEnd = pi >= ps.size() - 1;
  for (int i = 0; i <= maxp; i++) {
    cp[pi] = i;
    if (isEnd) {
      vector<int> usedPrimes;
      for (int j = pi; j >= 0; j--)
        if (ps[j].second.first > ps[j].second.second)
          usedPrimes.push_back(ps[j].first);
      count1(res, usedPrimes, mx / prod);
    } else {
      recur(res, ps, cp, pi + 1, prod, mx);
    }
    if (prod > mx / p) break;
    prod *= p;
    if (prod > mx) break;
  }
}
void recur2(long long& res, const vector<pair<int, pair<int, int> > >& ps,
            vector<int>& cp, int pi, long long prod, long long mx) {
  long long p = ps[pi].first;
  long long pa = ps[pi].second.first;
  long long pb = ps[pi].second.second;
  int maxp = pb;
  bool isEnd = pi >= ps.size() - 1;
  for (int i = 0; i <= maxp; i++) {
    cp[pi] = i;
    if (isEnd) {
      res++;
    } else {
      recur2(res, ps, cp, pi + 1, prod, mx);
    }
    if (prod > mx / p) break;
    prod *= p;
    if (prod > mx) break;
  }
}
int main(int argc, char* argv[]) {
  prepare();
  int t;
  cin >> t;
  {
    while (t--) {
      int nbrs[3][3];
      for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
          cin >> nbrs[i][j];
        }
      }
      map<int, int> n_primes;
      map<int, int> m_primes;
      map<int, int> s_primes;
      for (int i = 0; i < 3; i++) {
        swap(nbrs[0][i], nbrs[1][i]);
        genPrime(nbrs[0][i], n_primes);
        genPrime(nbrs[1][i], m_primes);
        genPrime(nbrs[2][i], s_primes);
      }
      s_primes[2]++;
      long long res = 0;
      {
        vector<pair<int, pair<int, int> > > ps =
            combinePrimes(m_primes, s_primes);
        long long pr = 1ll * nbrs[0][0] * nbrs[0][1] * nbrs[0][2];
        if (!ps.size()) {
          res += pr - 1;
        } else {
          vector<int> cP;
          cP.resize(ps.size(), 0);
          recur(res, ps, cP, 0, 1, pr);
        }
      }
      long long res2 = 0;
      {
        vector<pair<int, pair<int, int> > > ps =
            combinePrimes(s_primes, s_primes);
        long long pr = 1ll * nbrs[1][0] * nbrs[1][1] * nbrs[1][2];
        if (!ps.size()) {
          res2 = 1;
        } else {
          vector<int> cP;
          cP.resize(ps.size(), 0);
          recur2(res2, ps, cP, 0, 1, pr);
        }
      }
      printf("%lld\n", res + res2);
    }
  }
}
