#line 1 "a.cpp"
// https://qandori.github.io/cp-library/
#include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
using std::cin, std::cout, std::cerr;
#define vec vector
typedef long double ld;
#if LONG_MAX == 2147483647L
#undef long
#define long long long
#endif
#define uint unsigned int
#define ulong unsigned long
#define overload3(a, b, c, name, ...) name
#define rep3(i, a, b) for (int i = (a); i < (b); i++)
#define rep2(i, n) rep3(i, 0, n)
#define rep1(n) rep2(__i__, n)
#define rep(...) overload3(__VA_ARGS__, rep3, rep2, rep1)(__VA_ARGS__)
#define per3(i, a, b) for (int i = (b) - 1; i >= (a); i--)
#define per2(i, n) per3(i, 0, n)
#define per1(n) per2(__i__, n)
#define per(...) overload3(__VA_ARGS__, per3, per2, per1)(__VA_ARGS__)
#define CP_ALL_SELECT(first, ...) first
#define CP_ALL_RANGE(a) std::begin(a), std::end(a)
#define all(...) CP_ALL_SELECT(__VA_OPT__(CP_ALL_RANGE, ) all)(__VA_ARGS__)
#define UNIQUE(a) sort(all(a)), a.erase(unique(all(a)), a.end()), a.shrink_to_fit()
#define sz(a) static_cast<int>(a.size())
#ifndef DEBUG
#define cerr \
	if (false) cerr
#undef endl
#define endl '\n'
#endif
inline auto operator^=(vector<bool>::reference a, bool b) noexcept {
	if (b) a.flip();
	return a;
}
inline auto operator&=(vector<bool>::reference a, bool b) noexcept {
	if (!b) a = false;
	return a;
}
inline auto operator|=(vector<bool>::reference a, bool b) noexcept {
	if (b) a = true;
	return a;
}
inline ostream &operator<<(ostream &os, __int128_t value) {
	ostream::sentry s(os);
	if (s) {
		__uint128_t tmp = value;
		if (value < 0) tmp = -tmp;
		char buffer[128];
		char *d = std::end(buffer);
		do {
			--d;
			*d = "0123456789"[tmp % 10];
			tmp /= 10;
		} while (tmp != 0);
		if (value < 0) --d, *d = '-';
		const int len = std::end(buffer) - d;
		if (os.rdbuf()->sputn(d, len) != len) os.setstate(std::ios_base::badbit);
	}
	return os;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, pair<T, S> a) {
	return os << a.first << ' ' << a.second;
};
template <typename T>
ostream &operator<<(ostream &os, vector<T> a) {
	const int n = a.size();
	rep(i, n) {
		os << a[i];
		if (i + 1 != n) os << " ";
	}
	return os;
}
template <typename T, typename S>
istream &operator>>(istream &is, pair<T, S> &a) {
	return is >> a.first >> a.second;
}
template <typename T, size_t n>
ostream &operator<<(ostream &os, array<T, n> a) {
	rep(i, n) {
		os << a[i];
		if (i + 1 != n) os << " ";
	}
	return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &a) {
	for (T &i : a) is >> i;
	return is;
}
template <typename T, typename S>
bool chmin(T &x, S y) {
	if ((T)y < x) {
		x = (T)y;
		return true;
	}
	return false;
}
template <typename T, typename S>
bool chmax(T &x, S y) {
	if (x < (T)y) {
		x = (T)y;
		return true;
	}
	return false;
}
template <typename T>
void operator++(vector<T> &a) {
	for (T &i : a) ++i;
}
template <typename T>
void operator--(vector<T> &a) {
	for (T &i : a) --i;
}
template <typename T>
void operator++(vector<T> &a, int) {
	for (T &i : a) i++;
}
template <typename T>
void operator--(vector<T> &a, int) {
	for (T &i : a) i--;
}
void init(), solve();
int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	cout << fixed << setprecision(20);
	cerr << fixed << setprecision(20);
	init();
	int t = 1;
	cin >> t;
	while (t--) solve();
}
// #define COMB_MAX 1e6
// #include "lib/math/comb.hpp"
// #include "lib/fps/fps.hpp"
// #include "lib/math/mint.hpp"
void init() {}
#line 1 "lib/math/integer_division.hpp"



#line 1 "lib/components/integer_arithmetic.hpp"



#line 6 "lib/components/integer_arithmetic.hpp"
#include <type_traits>

namespace integer_arithmetic_detail {

template <class T>
inline constexpr bool integer = (std::is_integral_v<T> || std::is_same_v<T, __int128_t> || std::is_same_v<T, __uint128_t>) && !std::is_same_v<T, bool>;

template <class T>
constexpr T add(const T &a, const T &b) {
	if constexpr (integer<T>) {
		T result;
		if (__builtin_add_overflow(a, b, &result)) throw std::overflow_error("integer addition");
		return result;
	} else return a + b;
}

template <class T>
constexpr T multiply(const T &a, const T &b) {
	if constexpr (integer<T>) {
		T result;
		if (__builtin_mul_overflow(a, b, &result)) throw std::overflow_error("integer multiplication");
		return result;
	} else return a * b;
}

}


#line 8 "lib/math/integer_division.hpp"

template <class T, class U>
	requires (integer_arithmetic_detail::integer<T> && integer_arithmetic_detail::integer<U> && std::numeric_limits<T>::is_signed == std::numeric_limits<U>::is_signed)
constexpr std::common_type_t<T, U> floor_div(T a, U b) {
	using R = std::common_type_t<T, U>;
	R x = a, y = b;
	if (!y) throw std::invalid_argument("floor_div divisor");
	if constexpr (std::numeric_limits<R>::is_signed) {
		if (x == std::numeric_limits<R>::min() && y == -1) throw std::overflow_error("floor_div quotient");
		return x / y - (x % y != 0 && ((x < 0) != (y < 0)));
	} else return x / y;
}

template <class T, class U>
	requires (integer_arithmetic_detail::integer<T> && integer_arithmetic_detail::integer<U> && std::numeric_limits<T>::is_signed == std::numeric_limits<U>::is_signed)
constexpr std::common_type_t<T, U> ceil_div(T a, U b) {
	using R = std::common_type_t<T, U>;
	R x = a, y = b;
	if (!y) throw std::invalid_argument("ceil_div divisor");
	if constexpr (std::numeric_limits<R>::is_signed) {
		if (x == std::numeric_limits<R>::min() && y == -1) throw std::overflow_error("ceil_div quotient");
		return x / y + (x % y != 0 && ((x < 0) == (y < 0)));
	} else return x / y + (x % y != 0);
}


#line 143 "a.cpp"
void solve() {
	long a, b, sx, sy, tx, ty;
	cin >> a >> b >> sx >> sy >> tx >> ty;
	sx = floor_div(sx, a);
	sy = floor_div(sy, b);
	tx = floor_div(tx, a);
	ty = floor_div(ty, b);
	const long x = tx - sx, y = ty - sy;
	cout << abs(x) + abs(y) << endl;
}