#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <ctime>
#include <algorithm>
#include <sstream>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <cstdlib>
#include <cstdio>
#include <iterator>
#include <functional>
#include <bitset>
#include <random>

#ifdef LOCAL
#define eprintf(...) fprintf(stderr,__VA_ARGS__)
clock_t __my_start_clock = clock();
#else
#define eprintf(...)
#endif

#define TIMESTAMP(x) eprintf("["#x"] Time : %.3lf s.\n", (clock() - __my_start_clock)*1.0/CLOCKS_PER_SEC)
#define TIMESTAMPf(x,...) eprintf("[" x "] Time : %.3lf s.\n", __VA_ARGS__, (clock() - __my_start_clock)*1.0/CLOCKS_PER_SEC)

#define db(x) cerr << #x << " = " << x << endl
#define db2(x, y) cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n";
#define db3(x, y, z) cerr << "(" << #x << ", " << #y << ", " << #z << ") = (" << x << ", " << y << ", " << z << ")\n"
#define dbv(a) cerr << #a << " = "; for (auto xxxx: a) cerr << xxxx << " "; cerr << endl


using namespace std;

#ifdef LOCAL
static struct __timestamper {
    string what;
    __timestamper(const char* what) : what(what){};
    __timestamper(const string& what) : what(what){};
    ~__timestamper(){
        TIMESTAMPf("%s", what.data());
    }
} __TIMESTAMPER("end");
#else
struct __timestamper {};
#endif

typedef long long ll;
typedef long double dbl;

const int MOD = 998244353;

void add(int &x, int y) {
    x += y;
    if (x >= MOD) x -= MOD;
}

int mul(int x, int y) {
    return 1LL * x * y % MOD;
}

template <typename T>
struct fenwick {
    int n;
    vector<T> f;

    fenwick() {}

    fenwick(int N) {
        n = N;
        f.assign(N, T(0));
    }

    fenwick(vector<T> a) {
        n = a.size();
        for (int i = 0; i < n; i++) add(i, a[i]);
    }

    void add(int x, T y) {
        for (; x < n; x |= x + 1) f[x] += y;
    }

    T get(int x) {
        T res(0);
        for (; x >= 0; x = (x & (x + 1)) - 1) res += f[x];
        return res;
    }

    T get(int l, int r) {
        return get(r) - get(l - 1);
    }

    // return min i: sum(0, i) > x
    int upper_bound(T x) {
        int k = 1;
        while (2 * k <= n) k *= 2;

        int res = 0;
        while (k > 0) {
            if (f[res + k - 1] <= x) {
                x -= f[res + k - 1];
                res += k;
            }
            k /= 2;
        }
        return res;
    }
};

int main() {
#ifdef LOCAL
    freopen("in", "r", stdin);
#endif

    int T;
    scanf("%d", &T);
    while (T--) {
        int n;
        scanf("%d", &n);
        vector<int> a(n), b(n);
        for (int &x : b) scanf("%d", &x);
        for (int &x : a) scanf("%d", &x);

        auto cmp = [&](int i, int j) {
            return a[i] < a[j];
        };
        vector<int> va(n), vb(n);
        iota(va.begin(), va.end(), 0);
        sort(va.begin(), va.end(), cmp);

        bool ok = 1;
        int mn = -1;
        int sub = 0;
        for (int i : va) {
            int ca = a[i] - sub;
            if (ca < b[i] || b[i] < mn) ok = 0;
            sub += ca - b[i];
            mn = b[i];
        }
        if (ok) printf("%d\n", a[va[n - 1]] - b[va[n - 1]]);
        else printf("-1\n");

//        auto cmp_a = [&](int i, int j) {
//            if (a[i] != a[j]) return a[i] < a[j];
//            return b[i] > b[j];
////            return i < j;
//        };
//        auto cmp_b = [&](int i, int j) {
//            if (b[i] != b[j]) return b[i] < b[j];
//            return i < j;
//        };
//
//        vector<int> va(n), vb(n);
//        iota(va.begin(), va.end(), 0);
//        iota(vb.begin(), vb.end(), 0);
//        sort(va.begin(), va.end(), cmp_a);
//        sort(vb.begin(), vb.end(), cmp_b);
//
//        bool ok = 1;
//        int last = 0;
//        for (int i = 0; i < n; i++) {
//            int cur = a[va[i]] - b[va[i]];
//            ok &= cur >= last;
//            last = cur;
//        }
//        sort(va.begin(), va.end(), [&](int i, int j) {
//            return a[i] < a[j];
//        });
//        sort(vb.begin(), vb.end(), [&](int i, int j) {
//            return b[i] < b[j];
//        });
//
//        vector<int> open(n);
//        int cur_open = 0;
//
//        int lash_h = 0;
//
//        int added = 0;
//        int ca = 0, cb = 0;
//        while (ca < n || cb < n) {
//            if (ca == n || cb < n && b[vb[cb]] + added <= a[va[ca]]) {
//                if (cur_open > 0) {
//
//                }
//                open[vb[cb]] = 1;
//                cur_open++;
//                cb++;
//            }
//        }

//        vector<pair<int, int>> vct;
//        for (int i = 0; i < n; i++) {
//            vct.push_back({0, i});
//            vct.push_back({1, i});
//        }
//        auto val = [&](const pair<int, int> &x) {
//            if (x.first == 0) return a[x.second];
//            return b[x.second];
//        };
//        sort(vct.begin(), vct.end(), [&](const pair<int, int> &x, const pair<int, int> &y) {
//            if (val(x) != val(y)) {
//                return val(x) < val(y);
//            }
//            return x.first > y.first;
//        });
//
//        bool ok = 1;
//        vector<int> open(n);
//        int cnt_open = 0;
//        int last_h = 0;
//        int added = 0;
//        for (auto o : vct) {
//            int h = val(o);
//
//            if (cnt_open > 0) {
//                if (last_h != h) {
//                    added += h - last_h;
//                }
//            }
//
//            if (o.first == 0) {
//               ok &= open[o.second];
//               open[o.second] = 0;
//               cnt_open--;
//            } else {
//
//            }
//        }
//        auto v = b;
//        sort(v.begin(), v.end());
//        v.resize(unique(v.begin(), v.end()) - v.begin());
//        auto lb = [&](int x) {
//            return lower_bound(v.begin(), v.end(), x) - v.begin();
//        };
//        fenwick f(v.size() + 1);
//
//        vector<int> id(n);
//        iota(id.begin(), id.end(), 0);
//        sort(id.begin(), id.end(), [&](int i, int j) {
//            if (b[i] != b[j]) {
//                return b[i] < b[j];
//            }
//            return a[i] < a[j];
//        });
//
//        bool ok = 1;
//        ll sub = 0;
//        for (int ci : id) {
//            ll x = a[ci] - sub;
//            if (x < b[ci]) ok = 0;
//            else {
//                sub += x - b[ci];
//            }
//        }
    }

    return 0;
}