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

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

// 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 preSum(const P& t, int n) {
    i64 res = 0;
    for (int p = 0; p <= N; p++) {
        i64 tmp = 0, pw = 1;
        for (int i = 0; i <= p + 1; i++) {
            (tmp += t[p] * fact[p][i] % MOD * pw % MOD) %= MOD;
            pw = (pw * n % MOD) % MOD;
        }
        (res += tmp) %= MOD;
    }
    return res;
}

i64 rangeSum(const P& t, int l, int r) {
    return (preSum(t, r) + MOD - preSum(t, l - 1)) % MOD;
}

P polyMul(P x, 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(T a, 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, 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(P p0, 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;
            ans -= rangeSum(tr.allProd()[2][0], tml, tmr);
            ans -= rangeSum(tr.allProd()[2][1], tml, tmr);
            ans -= rangeSum(tr.allProd()[2][2], tml, tmr);
            // cout << tml << " " << tmr << ": " << ans << "\n";
            ((ans %= MOD) += MOD) %= MOD;
        }
    }
    cout << ans << "\n";
}

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