#include "bits/stdc++.h"
using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

  const int N = 1e6+7;
  int tt;
  cin >> tt;
  while(tt--) {
    int64_t a,b,c,d,v,t;
    cin >> a >> b >> c >> d >> v >> t;
    v++;
    int64_t ans = b*((t/a) + 1) + d*((t/c)+ 1);

    struct node {
      int presses = 0;
      int64_t time_from_zero = 0;
      bool valid = false;
    };

    vector<vector<node>> nodes(2, vector<node>(N, node{}));
    auto get_idx = [&](int mod_a, int mod_b)->pair<int, int> {
      if (mod_a == mod_b && mod_a == 0) {
        return {0, 0};
      } else if (mod_a == 0) {
        return {1, mod_b};
      } else if (mod_b == 0) {
        return {0, mod_a};
      } else assert(false);
      return {-1, -1};
    };

    auto dfs = [&](auto& self, int mod_a, int mod_c, bool ignore_valid)->void {
      if (t < 0) return;
      auto curridx = get_idx(mod_a, mod_c);
      auto currnode = nodes[curridx.first][curridx.second];
      int next_mod_a = (mod_a + v)%a;
      int a_diff = next_mod_a == 0?0:(a - next_mod_a);
      int next_mod_c = (mod_c + v)%c;
      int c_diff = next_mod_c == 0?0:(c - next_mod_c);
      if (a_diff <= c_diff) {
        next_mod_a = (next_mod_a + a_diff)%a;
        next_mod_c = (next_mod_c + a_diff)%c;
      } else {
        next_mod_a = (next_mod_a + c_diff)%a;
        next_mod_c = (next_mod_c + c_diff)%c;
      }
      auto nextidx = get_idx(next_mod_a, next_mod_c);
      if (!ignore_valid && nodes[nextidx.first][nextidx.second].valid) {
        // cycle completed!
        ans--; // make a press to go back to the beginning of the cycle.
        // Spend the time to go to the beginning of the cycle
        t -= v + min(a_diff, c_diff);
        // Already made all the steps necessary.
        if (t < 0) return;

        auto& nxtnode = nodes[nextidx.first][nextidx.second];
        int64_t total_cycle_time = currnode.time_from_zero - nxtnode.time_from_zero + min(a_diff, c_diff);
        int64_t total_cycle_presses = currnode.presses - nxtnode.presses + 1;
        int64_t num_cycles = t / total_cycle_time;
        t %= total_cycle_time;
        ans -= num_cycles * total_cycle_presses;
        self(self, next_mod_a, next_mod_c, true);
        return;
      } else {
        auto& nxtnode = nodes[nextidx.first][nextidx.second];
        // Make a press
        ans--;
        // Spend the time to go to the next step;
        t -= v + min(a_diff, c_diff);

        // Calculate the values of the next node.
        nxtnode.valid = true;
        nxtnode.presses = currnode.presses + 1;
        nxtnode.time_from_zero = currnode.time_from_zero + v + min(a_diff, c_diff);

        self(self, next_mod_a, next_mod_c, ignore_valid);
      }
    };
    nodes[0][0] = node{1, 0, true};
    dfs(dfs, 0, 0, false);

    cout << ans << '\n';
  }
}