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>
using namespace std;
using pii = pair<int, int>;
const int MOD = 1000000007;
const int INF = 2000000000;
const long long DESPACITO = 1000000000000000000;
namespace minmax {
template <class T>
T maxx(const T& A) {
  return A;
}
template <class T>
T minn(const T& A) {
  return A;
}
template <class T1, class T2>
T1 maxx(const T1& A, const T2& B) {
  return A > B ? A : B;
}
template <class T1, class T2>
T1 minn(const T1& A, const T2& B) {
  return A < B ? A : B;
}
template <class T, class... Ts>
T maxx(const T& A, const Ts&... ts) {
  T B = maxx(ts...);
  return A > B ? A : B;
}
template <class T, class... Ts>
T minn(const T& A, const Ts&... ts) {
  T B = minn(ts...);
  return A < B ? A : B;
}
template <class T, class... Ts>
T chmax(T& A, const Ts&... ts) {
  A = maxx(A, ts...);
  return A;
}
template <class T, class... Ts>
T chmin(T& A, const Ts&... ts) {
  A = minn(A, ts...);
  return A;
}
template <class T1, class T2, class T3, class T4>
void chmax2(T1& A, T2& Aa, const T3& B, const T4& Bb) {
  if (B > A) A = B, Aa = Bb;
}
template <class T1, class T2, class T3, class T4>
void chmin2(T1& A, T2& Aa, const T3& B, const T4& Bb) {
  if (B < A) A = B, Aa = Bb;
}
}  // namespace minmax
namespace input {
template <class T>
void re(T&& Xx) {
  cin >> Xx;
}
template <class T1, class T2>
void re(pair<T1, T2>& Pp) {
  re(Pp.first);
  re(Pp.second);
}
template <class T>
void re(vector<T>& Aa) {
  for (int i = 0; i < (int)(Aa).size(); i++) re(Aa[i]);
}
template <class T1, class T2>
void rea(T1&& Aa, T2 t) {
  for (int i = 0; i < t; i++) re(Aa[i]);
}
template <class T1, class T2, class... Ts>
void rea(T1&& Aa, T2 t, Ts&&... ts) {
  rea(Aa, t);
  rea(ts...);
}
template <class T1, class T2>
void rea1(T1&& Aa, T2 t) {
  for (int i = 1; i <= t; i++) re(Aa[i]);
}
template <class T1, class T2, class... Ts>
void rea1(T1&& Aa, T2 t, Ts&... ts) {
  rea1(Aa, t);
  rea1(ts...);
}
template <class T, class... Ts>
void re(T&& t, Ts&... ts) {
  re(t);
  re(ts...);
}
}  // namespace input
namespace output {
void pr(int32_t Xx) { cout << Xx; }
void pr(bool Xx) { cout << Xx; }
void pr(long long Xx) { cout << Xx; }
void pr(long long unsigned Xx) { cout << Xx; }
void pr(double Xx) { cout << Xx; }
void pr(char Xx) { cout << Xx; }
void pr(const string& Xx) { cout << Xx; }
void pr(const char* Xx) { cout << Xx; }
void pr(const char* Xx, size_t len) { cout << string(Xx, len); }
void ps() { cout << "\n"; }
void pn() {}
void pw() { pr(" "); }
void pc() {
  pr("]");
  ps();
}
template <class T1, class T2>
void pr(const pair<T1, T2>& Xx) {
  pr(Xx.first);
  pw();
  pr(Xx.second);
}
template <class T>
void pr(const T&);
bool parse(const char* t) {
  if (t == "\n") return true;
  return false;
}
template <class T>
bool parse(T&& t) {
  return false;
}
template <class T1, class T2>
bool parsepair(const pair<T1, T2>& Xx) {
  return true;
}
template <class T>
bool parsepair(T&& t) {
  return false;
}
template <class T1, class T2>
void psa(T1&& Aa, T2 t) {
  for (int i = 0; i < t; i++) pr(Aa[i]), pw();
  ps();
}
template <class T1, class T2>
void pna(T1&& Aa, T2 t) {
  for (int i = 0; i < t; i++) pr(Aa[i]), ps();
}
template <class T1, class T2>
void psa2(T1&& Aa, T2 t1, T2 t2) {
  for (int i = 0; i < t1; i++) {
    for (int j = 0; j < t2; j++) pr(Aa[i][j]), pw();
    ps();
  }
}
template <class T>
void pr(const T& Xx) {
  if (!(int)(Xx).size()) return;
  bool fst = 1;
  bool op = 0;
  if (parsepair(*Xx.begin())) op = 1;
  for (const auto& Aa : Xx) {
    if (!fst) pw();
    if (op) pr("{");
    pr(Aa), fst = 0;
    if (op) pr("}");
  }
}
template <class T, class... Ts>
void pr(const T& t, const Ts&... ts) {
  pr(t);
  pr(ts...);
}
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
  pr(t);
  if (sizeof...(ts)) {
    if (!parse(t)) pw();
  }
  ps(ts...);
}
template <class T>
void pn(const T& t) {
  for (const auto& Aa : t) ps(Aa);
}
template <class T, class... Ts>
void pw(const T& t, const Ts&... ts) {
  pr(t);
  if (sizeof...(ts)) pw();
  pw(ts...);
}
template <class T, class... Ts>
void pc(const T& t, const Ts&... ts) {
  bool op = 0;
  if (parsepair(t)) op = 1;
  if (op) pr("{");
  pr(t);
  if (op) pr("}");
  if (sizeof...(ts)) pr(", ");
  pc(ts...);
}
namespace trace {
template <class T1, class T2>
void __f(const char* name, const T1& Xx, const T2& y) {
  pr("[", y, "] = ");
  ps(Xx);
}
template <class T1, class T2, class... Ts>
void __f(const char* name, const T1& Xx, const T2& y, const Ts&... rest) {
  const char* open = strchr(name, '[');
  pr("[", y, "]");
  __f(open + 1, Xx, rest...);
}
template <class T1, class T2, class... Ts>
void __f0(const char* name, const T1& Xx, const T2& y, const Ts&... rest) {
  const char* open = strchr(name, '[');
  pr(name, size_t(open - name));
  __f(name, Xx, y, rest...);
}
template <class T>
void __fn(int n, const char* name, const T& Xx) {
  for (int i = 0; i < n; i++) pr(name), __f(name, Xx[i], i);
}
}  // namespace trace
}  // namespace output
using namespace minmax;
using namespace input;
using namespace output;
using namespace output::trace;
const int N = 2e5 + 5;
int solve() {
  int i = 0, j = 0, n;
  re(n);
  vector<int> a(2 * n), b(2 * n);
  for (i = 0; i < n; i++) re(a[i]), a[i + n] = a[i];
  for (i = 0; i < n; i++) re(b[i]), b[i + n] = b[i];
  i = j = 0;
  while (i < n) {
    int rem = 0, start = i;
    while (j < start + n) {
      int kill = max(0, a[j] - rem);
      if (b[j] < kill) break;
      rem = b[j] - kill;
      j++;
    }
    if (j == start + n) return ps("Yes"), 0;
    i = ++j;
  }
  ps("No");
  return 0;
}
int32_t main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int Q;
  for (cin >> Q; Q; Q--) solve();
  return 0;
}
