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

constexpr int MOD = 1e9 + 7, N = 150;

// fact[k][n]: [x^n](1^k + 2^k + 3^k + ... x^k)
i64 comb[N + 5][N + 5], fact[N + 5][N + 5];

i64 modPow(i64 a, i64 p) {
    i64 ans = 1;
    while (p) {
        if (p & 1) ans = ans * a % MOD;
        a = a * a % MOD;
        p >>= 1;
    }
    return ans;
}

i64 inv(i64 x) { return modPow(x, MOD - 2); }

void preCalc() {
    comb[0][0] = 1;
    for (int i = 1; i <= N; i++) {
        comb[i][0] = 1;
        for (int j = 1; j <= i; j++) {
            comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
            comb[i][j] %= MOD;
        }
    }

    fact[0][1] = 1;
    for (int k = 1; k <= N; k++) {
        for (int i = 0; i <= k + 1; i++) {
            (fact[k][i] += comb[k + 1][i]) %= MOD;
        }
        for (int p = 0; p < k; p++) {
            for (int i = 0; i <= p + 1; i++) {
                fact[k][i] -= comb[k + 1][p] * fact[p][i] % MOD;
                fact[k][i] = (fact[k][i] + MOD) % MOD;
            }
        }
        for (int i = 0; i <= k + 1; i++) {
            (fact[k][i] *= inv(k + 1)) %= MOD;
        }
    }
}

using P = array<int, N + 1>;

i64 rangeSum(const P& t, int l, int r) {
    l--;
    i64 res = 0;
    int deg = N;
    while (deg >= 0 && !t[deg]) deg--;
    for (int p = 0; p <= deg; p++) {
        i64 tmp = 0, pwr = 1, pwl = 1;
        for (int i = 0; i <= p + 1; i++) {
            (tmp += t[p] * fact[p][i] % MOD * pwr % MOD) %= MOD;
            (tmp -= t[p] * fact[p][i] % MOD * pwl % MOD) %= MOD;
            pwr = (pwr * r % MOD) % MOD;
            pwl = (pwl * l % MOD) % MOD;
        }
        (res += tmp) %= MOD;
    }
    (res += MOD) %= MOD;
    return res;
}

P polyMul(const P& x, const P& y, int l) {
    P ans{};
    for (int i = 0; i <= N; i++) {
        for (int j = 0; i + j <= min(l, N); j++) {
            (ans[i + j] += (i64)x[i] * y[j] % MOD) %= MOD;
        }
    }
    return ans;
}

using T = array<array<P, 3>, 3>;

T matMul(const T& a, const T& b, int l) {
    T res{};
    for (int i = 0; i < 3; i++) {
        for (int k = 0; k < 3; k++) {
            for (int j = 0; j < 3; j++) {
                P tmp = polyMul(a[i][k], b[k][j], l);
                for (int p = 0; p <= l && p <= N; p++) {
                    (res[i][j][p] += tmp[p]) %= MOD;
                }
            }
        }
    }
    return res;
}

P ep() {
    return {1};
}

T et() {
    T res{};
    res[0][0] = res[1][1] = res[2][2] = ep();
    return res;
}

constexpr int w = 256;
struct Segtree {    
    T tr[2 * w]{};

    Segtree() {
        fill(tr, tr + 2 * w, et());
    }

    void set(int p, const T& x) {
        int i = p + w, l = 2;
        for (tr[i] = x, i >>= 1; i; i >>= 1) {
            tr[i] = matMul(tr[2 * i], tr[2 * i + 1], l);
            l <<= 1;
        }
    }

    T allProd() { return tr[1]; }
};

T from01(const P& p0, const P& p1) {
    T res{};
    res[0][1] = res[1][2] = res[2][2] = p0;
    res[2][0] = p1;
    return res;
}

void solve() {
    int n; cin >> n;
    i64 allMul = 1;
    vector<int> l(n), r(n);
    for (int i = 0; i < n; i++) cin >> l[i];
    for (int i = 0; i < n; i++) cin >> r[i];

    Segtree tr{};

    struct Event {
        int time;
        int pos;
        array<array<int, 2>, 2> change;

        bool operator<(const Event &o) {
            return time < o.time;
        }
    };

    vector<Event> events;
    events.push_back({1, -1, {}});

    for (int i = 0; i < n; i++) {
        int s = r[i] - l[i] + 1;
        (allMul *= s) %= MOD;
        P p0 = {0}, p1 = {s};
        tr.set(i, from01(p0, p1));
        
        events.push_back({l[i], i, {{{(MOD - l[i]) % MOD, 1}, {(s + l[i]) % MOD, MOD - 1}}}});
        events.push_back({r[i] + 1, i, {{{s}, {0}}}});
    }

    sort(events.begin(), events.end());

    i64 ans = 0;

    int m = events.size();
    for (int i = 0; i < m; i++) {
        auto [t, p, pr] = events[i];
        if (p != -1) tr.set(p, from01({pr[0][0], pr[0][1]}, {pr[1][0], pr[1][1]}));
        if (i + 1 < m && events[i].time != events[i + 1].time) {
            int tml = events[i].time, tmr = events[i + 1].time - 1;
            ans += (tmr - tml + 1) * allMul % MOD;
            const auto m = tr.allProd();
            P tp = {0};
            for (int j = 0; j <= N; j++) {
                i64 tpj = 0;
                tpj += m[2][0][j];
                tpj += m[2][1][j];
                tpj += m[2][2][j];
                tp[j] = tpj % MOD;
            }
            ans -= rangeSum(tp, tml, tmr);
            // cout << tml << " " << tmr << ": " << ans << "\n";
            ((ans %= MOD) += MOD) %= MOD;
        }
    }
    cout << ans << "\n";
}

int main() {
    preCalc();
    int t; cin >> t; 
    while (t--) {
        solve();
    }
}