#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <array>
#include <vector>
#include <tuple>
#include <algorithm>
#include <cstdint>

using namespace std;

using vi = vector<int>;
using vb = vector<bool>;
using ll = long long;
using pll = pair<ll, ll>;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using vpll = vector<pll>;
using vpii = vector<pii>;
using vpil = vector<pil>;

int sum(int a, int b, int m) {
	if ((a += b) >= m) a -= m;
	return a;
}
int dif(int a, int b, int m) {
	if ((a -= b) < 0) a += m;
	return a;
}

struct Solver {
	const int N;
	vector<pair<int, pil>> a, c;
	Solver(const int N = 1e6) : N(N) {}
	void init() {
		a.assign(N, {});
		c.assign(N, {});
	}
	pair<int, pil>& get_element(const int ac, const int cc) {
		if (ac == 0)
			return a[cc];
		else
			return c[ac];
	}
} solver;

ll find_positive_ans(int a, int b, int c, int d, ll v, ll t) {
	return (t + a) / a * b + (t + c) / c * d;
}

int gcd(int a, int b) {
	while (b) {
		a %= b;
		swap(a, b);
	}
	return a;
}

// const int C = 3e6;

ll find_negative_ans(int a, int c, ll v, ll T, int i) {
	++v;
	//solver.init();
	int ares = v % a, cres = v % c, ac = 0, cc = 0;
	// ll cycle_length = (ll)a * (c / gcd(a, c));
	ll p = 0;
	bool found_cycle = false;
	//i *= C;
	for (ll t = 0; t <= T; t += v, ac = sum(ac, ares, a), cc = sum(cc, cres, c)) {
		int addend = min(dif(0, ac, a), dif(0, cc, c));
		if ((t += addend) > T)
			break;
		ac = sum(ac, addend, a);
		cc = sum(cc, addend, c);
		if (t == 0)
			++p;
		else {
			int removal = min((ac ? ac : a), (cc ? cc : c));
			if (removal >= v)
				++p;
		}
		if (found_cycle)
			continue;
		pair<int, pil>& last_time = solver.get_element(ac, cc);
		if (last_time.first <= i) {
			last_time.first = i + 1;
			last_time.second.first = p;
			last_time.second.second = t;
			continue;
		}
		found_cycle = true;
		ll cycle_len = t - last_time.second.second;
		ll cycle_load = p - last_time.second.first;
		ll cycles = (T - t) / cycle_len;
		p += cycles * cycle_load;
		t += cycles * cycle_len;
	}
	ac = 0; cc = 0;
	/*
	for (ll t = 0; t <= T; t += v, ac = sum(ac, ares, a), cc = sum(cc, cres, c)) {
		int addend = min(dif(0, ac, a), dif(0, cc, c));
		if ((t += addend) > T)
			break;
		ac = sum(ac, addend, a);
		cc = sum(cc, addend, c);
		pil& last_time = solver.get_element(ac, cc);
		if (last_time.first == 0)
			break;
		last_time.first = 0;
		last_time.second = 0;
	}
	*/
	return p;
}

ll find_ans(int a, int b, int c, int d, ll v, ll t, int i) {
	ll positive_ans = find_positive_ans(a, b, c, d, v, t);
	ll negative_ans = find_negative_ans(a, c, v, t, i);
	ll ans = positive_ans - negative_ans;
	return ans;
}

bool solve_test(int i) {
	int a, b, c, d;
	ll v, t;
	if (!(cin >> a >> b >> c >> d >> v >> t))
		return false;
	cout << find_ans(a, b, c, d, v, t, i) << '\n';
	return true;
}

void solve_tests() {
	solver.init();
	int t;
	cin >> t;
	for (int i = 0; i < t; ++i) {
		solve_test(i);
#ifdef ONPC
		//cerr << "Test " << i + 1 << " solved\n";
#endif
	}
}

#include <random>
tuple<int, int, int, int, ll, ll> get_rng_test() {
	static mt19937 rng;
	uniform_int_distribution<int> seg(1, 30);
	return { seg(rng), seg(rng), seg(rng), seg(rng), seg(rng), seg(rng) };
}

ll find_jury_negative_ans(int a, int c, ll v, ll T) {
	ll timer = 0;
	ll ans = 0;
	for (ll t = 0; t <= T; ++t, timer = max(0ll, timer - 1)) {
		if (t % a == 0 || t % c == 0) {
			if (timer == 0)
				++ans;
			timer = v + 1;
		}
	}
	return ans;
}

void stress() {
	int i = 0;
	solver.init();
	while (true) {
		if (i >= 150) {
			i = 0;
			solver.init();
		}
		auto [a, b, c, d, v, t] = get_rng_test();
		ll correct_ans = find_jury_negative_ans(a, c, v, t);
		ll my_ans = find_negative_ans(a, c, v, t, i);
		cerr << '.';
		if (correct_ans != my_ans) {
			cerr << "!!!\n";
			cerr << a << ' ' << c << ' ' << v << ' ' << t << '\n';
			cerr << correct_ans << ' ' << my_ans << '\n';
			return;
		}
		++i;
	}
}

#include <chrono>
int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
#ifdef ONPC
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	auto start = chrono::high_resolution_clock::now();
	solve_tests();
	auto finish = chrono::high_resolution_clock::now();
#ifdef ONPC
	cerr << "Taken " << (finish - start) / 1.ms << " ms\n";
	//stress();
#endif
}