The government of Berland decided to improve network coverage in his country. Berland has a unique structure: the capital in the center and n cities in a circle around the capital. The capital already has a good network coverage (so the government ignores it), but the i-th city contains a_i households that require a connection.

The government designed a plan to build n network stations between all pairs of neighboring cities which will maintain connections only for these cities. In other words, the i-th network station will provide service only for the i-th and the (i + 1)-th city (the n-th station is connected to the n-th and the 1-st city).

All network stations have capacities: the i-th station can provide the connection to at most b_i households.

Now the government asks you to check can the designed stations meet the needs of all cities or not — that is, is it possible to assign each household a network station so that each network station i provides the connection to at most b_i households.

Input

The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.

The first line of each test case contains the single integer n (2 ≤ n ≤ 10^6) — the number of cities and stations.

The second line of each test case contains n integers (1 ≤ a_i ≤ 10^9) — the number of households in the i-th city.

The third line of each test case contains n integers (1 ≤ b_i ≤ 10^9) — the capacities of the designed stations.

It's guaranteed that the sum of n over test cases doesn't exceed 10^6.

Output

For each test case, print YES, if the designed stations can meet the needs of all cities, or NO otherwise (case insensitive).

Example

Input


5
3
2 3 4
3 3 3
3
3 3 3
2 3 4
4
2 3 4 5
3 7 2 2
4
4 5 2 3
2 3 2 7
2
1 1
10 10


Output


YES
YES
NO
YES
YES

Note

In the first test case: 

  * the first network station can provide 2 connections to the first city and 1 connection to the second city; 
  * the second station can provide 2 connections to the second city and 1 connection to the third city; 
  * the third station can provide 3 connections to the third city. 



In the second test case: 

  * the 1-st station can provide 2 connections to the 1-st city; 
  * the 2-nd station can provide 3 connections to the 2-nd city; 
  * the 3-rd station can provide 3 connections to the 3-rd city and 1 connection to the 1-st station. 



In the third test case, the fourth city needs 5 connections, but the third and the fourth station has 4 connections in total.
#include <bits/stdc++.h>
inline long long ceil_div(long long a, long long b) { return (a + b - 1) / b; }
using namespace std;
inline int qr() {
  int f = 0, fu = 1;
  char c = getchar();
  while (c < '0' || c > '9') {
    if (c == '-') fu = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    f = (f << 3) + (f << 1) + (c & 15);
    c = getchar();
  }
  return f * fu;
}
const int N = 1e6 + 10, M = N * 4;
const long long INF = 2e18;
struct DINIC {
  int head[N << 1], ver[M << 1], Next[M << 1], d[N << 1];
  int s, t, tot = 1, n;
  queue<int> q;
  long long mxf, edge[M << 1];
  inline void init() {
    memset(head, 0, sizeof(int) * (n + 1));
    tot = 1, mxf = n = 0;
  }
  inline void add(int x, int y, int z) {
    n = max({n, x, y});
    ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
    ver[++tot] = x, edge[tot] = 0, Next[tot] = head[y], head[y] = tot;
  }
  inline bool bfs() {
    memset(d, 0, sizeof(int) * (n + 1));
    while (!q.empty()) q.pop();
    q.push(s), d[s] = 1;
    while (!q.empty()) {
      int x = q.front();
      q.pop();
      for (int i = head[x]; i; i = Next[i])
        if (edge[i] && !d[ver[i]]) {
          q.push(ver[i]);
          d[ver[i]] = d[x] + 1;
          if (ver[i] == t) return true;
        }
    }
    return false;
  }
  long long dinic(int x, long long flow) {
    if (x == t) return flow;
    long long rest = flow, k;
    for (int i = head[x]; i && rest; i = Next[i])
      if (edge[i] && d[ver[i]] == d[x] + 1) {
        k = dinic(ver[i], min(rest, 1ll * edge[i]));
        if (!k) d[ver[i]] = 0;
        edge[i] -= k, edge[i ^ 1] += k, rest -= k;
      }
    return flow - rest;
  }
  inline long long solve() {
    long long flow;
    while (bfs())
      while ((flow = dinic(s, INF))) mxf += flow;
    return mxf;
  }
} D;
int a[N], b[N], n, T;
int main() {
  T = qr();
  while (T--) {
    n = qr();
    for (register int i = 1; i <= n; ++i) a[i] = qr();
    for (register int i = 1; i <= n; ++i) b[i] = qr();
    D.init();
    D.s = 0, D.t = 2 * n + 1;
    for (int i = 1; i <= n; i++) D.add(0, i, b[i]);
    for (int i = 1; i <= n; i++) D.add(n + i, 2 * n + 1, a[i]);
    for (int i = 1; i <= n; i++) {
      D.add(i, n + i, b[i]);
      if (i < n)
        D.add(i, n + i + 1, b[i]);
      else
        D.add(i, n + 1, b[i]);
    }
    long long sum = 0;
    for (int i = 1; i <= n; i++) sum += a[i];
    puts(D.solve() == sum ? "YES" : "NO");
  }
  return 0;
}
