//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("avx2") // doesn't work on Yandex
//#pragma GCC target("avx") // for old judges
//#pragma GCC target("bmi,bmi2,lzcnt,popcnt") // fast bit operations

#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <cmath>
#include <algorithm>
#include <cassert>
#include <chrono>
#include <random>
#include <string>
#include <numeric>
#include <complex>
#include <tuple>
#include <utility>
#include <bitset>
#include <array>
#include <stack>
#include <sstream>
#include <unordered_set>

using namespace std;
typedef long long ll;

string to_string(string a) { return '"' + a + '"'; }
string to_string(char a) { return "'" + string(1, a) + "'"; }
string to_string(const char* a) { return to_string((string) a); }
string to_string(bool a) { return a ? "true" : "false"; }
template <class T1, class T2>
string to_string(pair<T1, T2> a) {
    return "(" + to_string(a.first) + ", " + to_string(a.second) + ")";
}
template <class T>
string to_string(T a) {
    bool first = true; string res = "{";
    for (const auto& i : a) {
        if (!first) res += ", ";
        first = false;
        res += to_string(i);
    }
    res += "}";
    return res;
}
void debug_out() { cerr << endl; }
template <class T1, class... T2>
void debug_out(T1 a, T2... b) {
    cerr << " " << to_string(a);
    debug_out(b...);
}

#ifdef LOCAL
#define out(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define out(...) 42
#endif

clock_t start_time; void start_timer() { start_time = clock(); }
double get_time() { return (double) (clock() - start_time) / CLOCKS_PER_SEC; }

void Solve();

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
#ifdef LOCAL
    freopen("usr/share/man/man1/input.txt", "r", stdin);
#endif
    start_timer();
    Solve();
#ifdef LOCAL
    cerr << fixed << setprecision(3);
    cerr << endl << "Time spent: " << get_time() << endl;
#endif
    return 0;
}

// do something, stay focused
// look for stupid bugs
// guess, slow, stress
// don't overgeneralize
// don't rush

// don't waste time on standings

// SOLVE THE PROBLEM OR DIE TRYING
// THE SOLUTION IS ALWAYS SIMPLE
// THE CODE IS ALWAYS SHORT

const int mod = 1e9 + 7;

int add(int a, int b) {
    a += b;
    if (a >= mod) a -= mod;
    return a;
}

int sub(int a, int b) {
    a -= b;
    if (a < 0) a += mod;
    return a;
}

int mult(int a, int b) {
    return a * 1ll * b % mod;
}

int bit(int mask, int i) {
    return (mask >> i) & 1;
}

const int CARD = (1 << 0) | (1 << 3) | (1 << 6) | (1 << 9);

vector<int> masks;

int sol(int H, int W, int h[3], int w[3]) {
    bool full = 0;
    for (int i = 0; i <= 2; i++) {
        if (h[i] == H && w[i] == W) {
            full = 1;
            break;
        }
    }
    int ans = 0;
    if (full) {
        ans = 1;
        for (int i = 0; i <= 2; i++) {
            ans = mult(ans, mult(H - h[i] + 1, W - w[i] + 1));
        }
        return ans;
    }
    for (int mask : masks) {
        bool bad = 0;
        vector<int> unfixed;
        for (int i = 0; i <= 2; i++) {
            int card = CARD & (mask >> i);
            int cnt = __builtin_popcount(card);
            if (cnt == 2) {
                for (int j = 0; j <= 3; j++) {
                    int nxt = (j + 1) % 4;
                    int side = (1 << (3 * j)) | (1 << (3 * nxt));
                    if (card == side) {
                        if ((j % 2 == 0 && w[i] < W) || (j % 2 == 1 && h[i] < H)) {
                            bad = 1;
                            break;
                        }
                    }
                }
                if (bad) {
                    break;
                }
            }
            if (cnt == 1 && (h[i] == H || w[i] == W)) {
                bad = 1;
                break;
            }
            if (cnt == 0) {
                if (h[i] + w[i] >= H + W - 1) {
                    bad = 1;
                    break;
                }
                unfixed.push_back(i);
            }
        }
        if (bad) {
            continue;
        }
        if (unfixed.empty()) {
            for (int j = 0; j <= 3; j++) {
                int nxt = (j + 1) % 4;
                int mx_j = 0;
                int mx_nxt = 0;
                if (j % 2 == 0) {
                    for (int i = 0; i <= 2; i++) {
                        if (bit(mask, 3 * j + i)) {
                            mx_j = max(mx_j, w[i]);
                        }
                        if (bit(mask, 3 * nxt + i)) {
                            mx_nxt = max(mx_nxt, w[i]);
                        }
                    }
                    if (mx_j + mx_nxt < W) {
                        bad = 1;
                        break;
                    }
                }
                else {
                    for (int i = 0; i <= 2; i++) {
                        if (bit(mask, 3 * j + i)) {
                            mx_j = max(mx_j, h[i]);
                        }
                        if (bit(mask, 3 * nxt + i)) {
                            mx_nxt = max(mx_nxt, h[i]);
                        }
                    }
                    if (mx_j + mx_nxt < H) {
                        bad = 1;
                        break;
                    }
                }
            }
            if (bad) {
                continue;
            }
            ans = add(ans, 1);
        }
        else if (unfixed.size() == 1) {
            int id = unfixed[0];
            int i0 = -1;
            int i1 = -1;
            int i2 = id;
            for (int i = 0; i <= 2; i++) {
                if (i != id) {
                    if (i0 == -1) {
                        i0 = i;
                    }
                    else {
                        i1 = i;
                    }
                }
            }
            if (h[i0] == H && h[i1] == H && w[0] + w[1] + w[2] >= W) {
                int w0 = w[i0];
                int w1 = w[i1];
                int w2 = w[i2];
                int h2 = h[i2];
                if (w0 + w1 >= W) {
                    ans = add(ans, sub(mult(W - w2 + 1, H - h2 + 1), (2 - (w2 == W)) * (2 - (h2 == H))));
                }
                else if (h2 == H) {
                    int l = max(1, W - w1 - w2);
                    int r = min(w0, W - 1 - w2);
                    assert(l <= r);
                    ans = add(ans, r - l + 1);
                }
            }
            else if (w[i0] == W && w[i1] == W && h[0] + h[1] + h[2] >= H) {
                int h0 = h[i0];
                int h1 = h[i1];
                int h2 = h[i2];
                int w2 = w[i2];
                if (h0 + h1 >= H) {
                    ans = add(ans, sub(mult(W - w2 + 1, H - h2 + 1), (2 - (w2 == W)) * (2 - (h2 == H))));
                }
                else if (w2 == W) {
                    int l = max(1, H - h1 - h2);
                    int r = min(h0, H - 1 - h2);
                    assert(l <= r);
                    ans = add(ans, r - l + 1);
                }
            }
        }
        else {
            assert(0);
        }
    }
    return ans;
}

int slow(int H, int W, int h[3], int w[3]) {
    int res = 0;
    int x[3] = {};
    int y[3] = {};
    for (x[0] = 0; x[0] + h[0] <= H; x[0]++) {
        for (y[0] = 0; y[0] + w[0] <= W; y[0]++) {
            for (x[1] = 0; x[1] + h[1] <= H; x[1]++) {
                for (y[1] = 0; y[1] + w[1] <= W; y[1]++) {
                    for (x[2] = 0; x[2] + h[2] <= H; x[2]++) {
                        for (y[2] = 0; y[2] + w[2] <= W; y[2]++) {
                            //out(x[0], x[1], x[2]);
                            //out(y[0], y[1], y[2]);
                            bool cov = 1;
                            for (int i = 0; i < H; i++) {
                                for (int j = 0; j < W; j++) {
                                    bool cur = 0;
                                    for (int k = 0; k <= 2; k++) {
                                        cur |= (x[k] <= i && i < x[k] + h[k]) && (y[k] <= j && j < y[k] + w[k]);
                                    }
                                    if (!cur) {
                                        cov = 0;
                                        break;
                                    }
                                }
                                if (!cov) {
                                    break;
                                }
                            }
                            if (cov) {
                                res++;
                            }
                        }
                    }
                }
            }
        }
    }
    return res % mod;
}

void stress() {
    /*
    int H = 2;
    int W = 3;
    int h[] = {1, 1, 1};
    int w[] = {3, 1, 1};
    out(slow(H, W, h, w));
    return;
    */
    
    mt19937 rnd;
    for (int q = 1; q <= 1; q++) {
        /*
        int H = rnd() % 100 + 1;
        int W = rnd() % 100 + 1;
        int h[3];
        int w[3];
        for (int i = 0; i <= 2; i++) {
            h[i] = rnd() % H + 1;
            w[i] = rnd() % W + 1;
        }
        */
        int H = 100;
        int W = 101;
        int h[3] = {100, 99, 1};
        int w[3] = {101, 100, 1};
        
        int slow_ans = slow(H, W, h, w);
        int sol_ans = sol(H, W, h, w);
        out(slow_ans, sol_ans);
        if (slow_ans != sol_ans) {
            out(slow_ans);
            out(sol_ans);
            out(H, W);
            out(h[0], w[0]);
            out(h[1], w[1]);
            out(h[2], w[2]);
            return;
        }
    }
}

void Solve() {
    for (int mask = 0; mask < (1 << 12); mask++) {
        bool bad = 0;
        for (int j = 0; j <= 3; j++) {
            int cov = (mask >> (3 * j)) & 7;
            if (!cov) {
                bad = 1;
                break;
            }
        }
        for (int i = 0; i <= 2; i++) {
            int card = CARD & (mask >> i);
            int cnt = __builtin_popcount(card);
            if (cnt >= 3) {
                bad = 1;
                break;
            }
            if (cnt == 2) {
                int diag = 1 + (1 << 6);
                if (card == diag || card == (diag << 3)) {
                    bad = 1;
                    break;
                }
            }
        }
        if (!bad) {
            masks.push_back(mask);
        }
    }
    
    //stress();
    //return;
    
    int T;
    cin >> T;
    while (T--) {
        int H, W;
        int h[3];
        int w[3];
        cin >> H >> W;
        for (int i = 0; i <= 2; i++) {
            cin >> h[i] >> w[i];
        }
        int ans = sol(H, W, h, w);
        cout << ans << "\n";
    }
}