#pragma GCC optimize(0)
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const ll mod = 1e9 + 7;

ll T, W, H, ans, a[3], b[3], c[3], d[3];

inline void addmod(ll &x) {
	(x >= mod) && (x -= mod);
}

bitset <15> tmp[15];
vector <int> vec;

int a1[3], a2[3], b1[3], b2[3];

inline bool check() {
	bool flg1 = false, flg4 = false;
	for (int i = 0; i < 3; ++i) {
		flg1 |= (c[i] == 1);
	}
	for (int i = 0; i < 3; ++i) {
		flg4 |= (c[i] == 4);
	}
	if (!flg1 || !flg4) {
		return false;
	}
	for (int i = 0; i < 15; ++i) {
		tmp[i].reset();
	}
	for (int i = 0; i < 3; ++i) {
		a1[i] = 0, b1[i] = 0;
		a2[i] = 0, b2[i] = 0;
		if (c[i] == 1) {
			a1[i] = 0, b1[i] = 0;
			a2[i] = a[i], b2[i] = b[i];
		}
		if (c[i] == 2) {
			a1[i] = W - a[i], b1[i] = 0;
			a2[i] = W, b2[i] = b[i];
		}
		if (c[i] == 3) {
			a1[i] = 0, b1[i] = H - b[i];
			a2[i] = a[i], b2[i] = H;
		}
		if (c[i] == 4) {
			a1[i] = W - a[i], b1[i] = H - b[i];
			a2[i] = W, b2[i] = H;
		}
		if (c[i]) {
			vec.emplace_back(a1[i]);
			vec.emplace_back(a2[i]);
			vec.emplace_back(b1[i]);
			vec.emplace_back(b2[i]);
		}
	}
	vec.emplace_back(0);
	vec.emplace_back(H);
	vec.emplace_back(W);
	sort(vec.begin(), vec.end());
	vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
	for (int i = 0; i < 3; ++i) {
		if (c[i]) {
			a1[i] = lower_bound(vec.begin(), vec.end(), a1[i]) - vec.begin();
			b1[i] = lower_bound(vec.begin(), vec.end(), b1[i]) - vec.begin();
			a2[i] = lower_bound(vec.begin(), vec.end(), a2[i]) - vec.begin();
			b2[i] = lower_bound(vec.begin(), vec.end(), b2[i]) - vec.begin();
		}
	}
	int w = lower_bound(vec.begin(), vec.end(), W) - vec.begin();
	int h = lower_bound(vec.begin(), vec.end(), H) - vec.begin();
	for (int i = 0; i < 3; ++i) {
		for (int j = a1[i]; j < a2[i]; ++j) {
			for (int k = b1[i]; k < b2[i]; ++k) {
				tmp[j][k] = 1;
			}
		}
	}
	for (int i = 0; i < w; ++i) {
		if ((int)tmp[i].count() != h) {
			return false;
		}
	}
	return true;
}

inline void calc() {
	ll t = 1;
	int cnt = 0;
	for (int i = 0; i < 3; ++i) {
		if (!c[i]) {
			t = t * d[i] % mod;
			++cnt;
		}
	}
	if (cnt >= 2) {
		return;
	}
	if (check()) {
		addmod(ans += t);
	}
}

inline void dfs(int u) {
	if (u == 3) {
		calc();
		return;
	}
	if (a[u] == W) {
		for (auto p: {0, 1, 4}) {
			c[u] = p;
			dfs(u + 1);
		}
	} else if (b[u] == H) {
		for (auto p: {0, 1, 4}) {
			c[u] = p;
			dfs(u + 1);
		}
	} else {
		for (auto p: {0, 1, 2, 3, 4}) {
			c[u] = p;
			dfs(u + 1);
		}
	}
}

inline void calc1(int x, int y, int z) {
	if (b[x] + b[z] >= H) {
		addmod(ans += H - 1 - b[y]);
	} else {
		int l = max(2ll, H - b[z] - b[y] + 1), r = min(H - b[y], b[x] + 1);
		if (l <= r) {
			addmod(ans += r - l + 1);
		}
	}
}

inline void calc2(int x, int y, int z) {
	if (max(b[x], b[y]) + b[z] >= H) {
		addmod(++ans);
	}
}

inline void solve() {
	cin >> W >> H;
	for (int i = 0; i < 3; ++i) {
		cin >> a[i] >> b[i];
	}
	ans = 0;
	for (int i = 0; i < 3; ++i) {
		if (a[i] == W && b[i] == H) {
			ans = 1;
			for (int j = 0; j < 3; ++j) {
				ans = ans * (W - a[j] + 1) % mod * (H - b[j] + 1) % mod;
			}
			cout << ans << "\n";
			return;
		}
	}
	bool flg = false;
	for (int i = 0; i < 3; ++i) {
		if (a[i] == W || b[i] == H) {
			flg = true;
		}
	}
	if (!flg) {
		cout << "0\n";
		return;
	}
	if (b[0] == H && b[1] == H && b[2] == H) {
		swap(H, W);
		swap(a[0], b[0]);
		swap(a[1], b[1]);
		swap(a[2], b[2]);
	}
	if (a[0] == W && a[1] == W && a[2] == W) {
		if (b[0] + b[1] + b[2] < H) {
			cout << "0\n";
			return;
		}
		calc1(0, 1, 2);
		calc1(0, 2, 1);
		calc1(1, 0, 2);
		calc1(1, 2, 0);
		calc1(2, 0, 1);
		calc1(2, 1, 0);
		calc2(0, 1, 2);
		calc2(0, 2, 1);
		calc2(1, 0, 2);
		calc2(1, 2, 0);
		calc2(2, 0, 1);
		calc2(2, 1, 0);
		cout << ans << "\n";
		return;
	}
	for (int i = 0; i < 3; ++i) {
		d[i] = (W - a[i] + 1) % mod * (H - b[i] + 1) % mod;
		if (a[i] == W || b[i] == H) {
			addmod(d[i] += mod - 2);
		} else {
			addmod(d[i] += mod - 4);
		}
	}
	dfs(0);
	cout << ans << "\n";
}

int main() {
	#ifdef LOCAL
		assert(freopen("test.in", "r", stdin));
		assert(freopen("test.out", "w", stdout));
	#endif
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}