#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


template <class U, class T> T pathUnder(U m, U a, U b, U n, T e, T x, T y) {
  U c = (a * n + b) / m;
  T pre = e, suf = e;
  for (; ; ) {
    const U p = a / m; a %= m; x = x * y.pow(p);
    const U q = b / m; b %= m; pre = pre * y.pow(q);
    c -= (p * n + q);
    if (c == 0) return pre * x.pow(n) * suf;
    const U d = (m * c - b - 1) / a + 1;
    suf = y * x.pow(n - d) * suf;
    b = m - b - 1 + a; swap(m, a); n = c - 1; c = d; swap(x, y);
  }
}

struct Data {
  Int val, sum0, sum1;
  Data() : val(0), sum0(0), sum1(0) {}
  Data(Int val_, Int sum0_, Int sum1_) : val(val_), sum0(sum0_), sum1(sum1_) {}
  friend Data operator*(const Data &a, const Data &b) {
    return Data(a.val + b.val, a.sum0 + b.sum0, a.sum1 + b.sum1 + a.val * b.sum0);
  }
  Data pow(Int e) const {
    assert(e >= 0);
    return Data(e * val, e * sum0, e * sum1 + (e * (e - 1) / 2) * val * sum0);
  }
};

Int sumFloors(Int M, Int A, Int B, Int N) {
  return pathUnder<unsigned long long>(M, A, B, N,
        Data(), Data(0, 1, 0), Data(1, 0, 0)).sum1;
}


Int brute(Int A, Int B, Int C, Int D, Int V, Int T) {
  Int led = 0, counter = 0, last = 0;
  for (Int t = 0; t <= T; ++t) {
    auto push = [&]() -> void {
      if (t - last > V) {
        led = 0;
      }
      if (!led) {
        led = 1;
      } else {
        ++counter;
      }
      last = t;
    };
    if (t % A == 0) for (Int b = 0; b < B; ++b) push();
    if (t % C == 0) for (Int d = 0; d < D; ++d) push();
  }
  return counter;
}

Int solve(Int A, Int B, Int C, Int D, Int V, Int T) {
  const Int X = T / A;
  const Int Y = T / C;
  Int ans = 0;
  if (A <= V || C <= V) {
    ans += (X + 1) * B;
    ans += (Y + 1) * D;
    ans -= 1;
  } else {
    ans += (X + 1) * (B - 1);
    ans += (Y + 1) * (D - 1);
    ans += (sumFloors(A, C, A, Y + 1) - sumFloors(A, C, A - V - 1, Y + 1));
    ans += (sumFloors(C, A, C, X + 1) - sumFloors(C, A, C - V - 1, X + 1));
    ans -= (T / (A / __gcd(A, C) * C) + 1);
  }
  return ans;
}

void stress() {
  constexpr Int LIM = 20;
#define rep(i) for (int i = 1; i <= LIM; ++i)
  rep(A) rep(B) rep(C) rep(D) rep(V) rep(T) {
    const Int brt = brute(A, B, C, D, V, T);
    const Int slv = solve(A, B, C, D, V, T);
    if (brt != slv) {
      cerr << A << " " << B << " " << C << " " << D << " " << V << " " << T << ": " << brt << " " << slv << endl;
    }
    assert(brt == slv);
  }
#undef rep
}

// [0, 2^32)
unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}
void stressLarge() {
  for (int t = 0; t < 1'000'000; ++t) {
    const Int A = 1 + xrand() % 1'000'000;
    const Int B = 1 + xrand() % 1'000'000;
    const Int C = 1 + xrand() % 1'000'000;
    const Int D = 1 + xrand() % 1'000'000;
    const Int V = 1 + 1ULL * xrand() * xrand() % 1'000'000'000'000LL;
    const Int T = 1 + 1ULL * xrand() * xrand() % 1'000'000'000'000LL;
    const Int slv = solve(A, B, C, D, V, T);
    printf("%lld\n", slv);
  }
}

int main() {
#ifdef LOCAL
  // stress();
  // stressLarge();
#endif
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    Int A, B, C, D, V, T;
    scanf("%lld%lld%lld%lld%lld%lld", &A, &B, &C, &D, &V, &T);
    
    const Int ans = solve(A, B, C, D, V, T);
    printf("%lld\n", ans);
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}