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

#define FILE_IO
namespace io {
    #ifdef FILE_IO
    #define FREAD
    #define FWRITE
    #endif

    #ifdef FREAD
    static char ibuf[100000], *p1 = ibuf, *p2 = ibuf;
    #define getchar() (p1 == p2 && (p2 = (p1 = ibuf) + fread(ibuf, 1, 100000, stdin), p1 == p2) ? EOF : *p1++)
    #endif
    
    #ifdef FWRITE
    static char obuf[100000], *p3 = obuf;
    #define putchar(x) ((p3 - obuf < 100000) ? (*p3++ = (x)) : (fwrite(obuf, p3 - obuf, 1, stdout), p3 = obuf, *p3++ = (x)))
    struct flasher { ~flasher() { fwrite(obuf, p3 - obuf, 1, stdout); } }flash;
    #endif
    //读入失败返回true
    template <class T> bool read(T &r) {
        r = 0; static char ch = getchar(); bool f = false;
        while (ch < 48 || ch > 57) { if (ch == EOF) return true; if (ch == 45) f ^= 1; ch = getchar(); }
        while (ch >= 48 && ch <= 57) { r = r * 10 + ch - 48; ch = getchar(); }
        if (f) r = -r; return false;
    }
    template <class T> void write(T w, char end = '\n') {
        static char write_buf[55]; char *pos = write_buf;
        if (w == 0) { putchar('0'); putchar(end); return; }
        if (w < 0) { putchar('-'); w = -w; }
        while (w) {
            *(pos++) = w % 10 + '0';
            w /= 10;
        }
        while (pos != write_buf) putchar(*(--pos));
        putchar(end);
    }
};
using namespace io;

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")

const int MOD(1e9 + 7);

int h, w;
int a[5], b[5];
const int p[4][2] = {
	{0, 0}, 
	{1, 0},
	{0, 1}, 
	{1, 1}
};

int ans;
int cover[5];
pair<int, int> need[5];
set<pair<int, int>> noneed[5];
int mh[5], mw[5];

void dfs(int id) {
	if (id == 4) {
		int sp = -1;
		for (int j = 0; j < 3; j++) 
			if (need[j] == make_pair(-1, -1)) 
				sp = j;
		
		if (sp != -1) {
			int jl = (sp + 1) % 3, jr = (sp + 2) % 3;
			if (need[jr] == make_pair(0, 0)) swap(jl, jr);

			if (a[jl] == h) {
				if (b[jl] + b[jr] < w) {
					if (a[sp] != h) return;
					int l = max(1, w - b[jr] - b[sp]);
					int r = min(w - b[sp] - 1, b[jl]);
					if (l <= r) ans = (ans + r - l + 1) % MOD;
					else return;
				} else ans = (ans + 1ll * (h - a[sp] + 1) * (w - b[sp] + 1) - noneed[sp].size()) % MOD;
			} else {
				if (a[jl] + a[jr] < h) {
					if (b[sp] != w) return;
					int l = max(1, h - a[jr] - a[sp]);
					int r = min(h - a[sp] - 1, a[jl]);
					if (l <= r) ans = (ans + r - l + 1) % MOD;
					else return;
				} else ans = (ans + 1ll * (h - a[sp] + 1) * (w - b[sp] + 1) - noneed[sp].size()) % MOD;
			}
		} else {
			if (
				mh[0] + mh[1] >= h && 
				mh[2] + mh[3] >= h &&
				mw[0] + mw[2] >= w &&
				mw[1] + mw[3] >= w
			) ans = (ans + 1) % MOD;
		}
		return;
	}

	for (cover[id] = 1; cover[id] < 7; cover[id]++) {
		bool book[5] = {0,0,0,0,0};
		mh[id] = mw[id] = 0;
		bool flag = true;
		
		for (int j = 0; j < 3; j++) {
			auto po = make_pair(
				p[id][0] * (h - a[j]), 
				p[id][1] * (w - b[j])
			);
			if ((cover[id] >> j) & 1) {
				mh[id] = max(mh[id], a[j]);
				mw[id] = max(mw[id], b[j]);
				if (need[j] == make_pair(-1, -1)) {
					book[j] = true;
					need[j] = po;
				}
				else if (need[j] != po) flag = false;
			} else if (!noneed[j].count(po)) {
				noneed[j].emplace(po);
				book[j] = true;
			}
			if (noneed[j].count(need[j])) flag = false;
		}
		if (flag) dfs(id + 1);
		for (int j = 0; j < 3; j++) {
			if (book[j]) {
				auto po = make_pair(
					p[id][0] * (h - a[j]), 
					p[id][1] * (w - b[j])
				);
				if ((cover[id] >> j) & 1) need[j] = make_pair(-1, -1);
				else noneed[j].erase(po);
			}
		}
	}
}

void solve() {
	read(h); read(w);
	for (int i = 0; i < 3; i++) {
		read(a[i]); read(b[i]);
	}
	for (int i = 0; i < 3; i++) {
		if (a[i] == h && b[i] == w) {
			write(
				1ll * (h - a[0] + 1) % MOD * (w - b[0] + 1) % MOD *
				(h - a[1] + 1) % MOD * (w - b[1] + 1) % MOD *
				(h - a[2] + 1) % MOD * (w - b[2] + 1) % MOD
			);
			return;
		}
		need[i] = make_pair(-1, -1);
	}
	ans = 0;
	dfs(0);
	write(ans);
}

int main() {
	int _;
	read(_);
	while (_--) {
		solve();
	}
	return 0;
}