//#include <bits/stdc++.h>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <cassert>
#include <vector>
#include <map>

using namespace std;
namespace Fast {
inline char getc() {
    static char buf[1 << 21], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + 
        fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
}
inline void read() {}
template <typename T1, typename... T2>
inline void read(T1 &x, T2 &... oth) {
    bool f = false;
    x = 0;
    char ch = getchar();
    while (!isdigit(ch)) {
        if (ch == '-')
            f = true;
        ch = getchar();
    }
    while (isdigit(ch)) {
        x = (x << 1) + (x << 3) + (ch - 48);
        ch = getchar();
    }
    x = f ? -x : x;
    read(oth...);
}

template <typename T>
inline void print(T x) {
    if (x < 0) {
        putchar('-');
        x = ~(x - 1);
    }
    char f[100];
    int top = 0;
    while (x) f[++top] = x % 10 + '0', x /= 10;
    if (!top) f[++top] = '0';
    while (top) putchar(f[top--]);
}
template <typename T>
inline void print(T x, char c) {
    print(x);
    putchar(c);
}
} // namespace Fast

#define debug printf("(hao)")
#define all(x) x.begin(), x.end()
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define clr(a, v) memset(a, v, sizeof(a))
#define MO(x) ((x) % mod)
#define br(x) putchar(x)
#define pb(x) push_back(x)
#define eb(x) emplace_back(x)
#define fi first
#define se second
#define mp make_pair
using ll = long long;
using vi  = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using Fast::read;
// using Fast::print;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const ll LLF = 0x3f3f3f3f3f3f3f3f;
const int M = 2e5 + 10;

template <typename T>
T gcd(T a, T b, T m = 0) { while (b) m = a % b, a = b, b = m; return a; }

template <typename T>
inline void input_arr(T *a, int l, int r) { while (l < r) read(a[l++]); }
ll c[M], a[M], b[M];
/*===========================================================================*/
void solve() {
    int n;
    read(n);
    for (int i = 1; i <= n; ++i) read(c[i]);
    for (int i = 1; i <= n; ++i) read(a[i]);
    for (int i = 1; i <= n; ++i) read(b[i]);
    ll ans = c[n] - 1, last = c[n] - 1;
    for (int i = n - 1; i >= 1; --i) {
        last += 2;
        if (i == 1) {
            // printf("(%d)", last);
            ans = max(last + abs(a[i + 1] - b[i + 1]), ans);
            break;
        }
        if (a[i + 1] == b[i + 1]) {
            ans = max(last, ans);
            last = c[i] - 1;
        } else {
            ll tmp = abs(a[i + 1] - b[i + 1]);
            ans = max(ans, last + tmp);
            last = max(c[i] - 1 - tmp + last, c[i] - 1);
        }
    }
    printf("%lld\n", ans);
}
/*===========================================================================*/
#include <ctime>

clock_t ___;
int main() {
    std::ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
#ifndef ONLINE_JUDGE
    freopen("D:/MYCODE/vsCode-c/test.in", "r", stdin);
    freopen("D:/MYCODE/vsCode-c/test.out", "w", stdout);
#endif
    
    int _ = 1;
    read(_);
    // cin >> _;
    ___ = clock();
    while (_--) solve();
#ifndef ONLINE_JUDGE
    cerr << clock() - ___ << "ms\n";
#endif
    return 0;
}

/*
11111111111111111111-----神龙保佑,永无BUG-----11111111111111111111
11111111111111111111111111111111100001111111111111111111111111111
11111111111111111111111111111110000111111111111111111111111111111
11111111111111111111111111111000000111111111111111111111111111111
11111111111111111111111111100000011110001100000000000000011111111
11111111111111111100000000000000000000000000000000011111111111111
11111111111111110111000000000000000000000000000011111111111111111
11111111111111111111111000000000000000000000000000000000111111111
11111111111111111110000000000000000000000000000000111111111111111
11111111111111111100011100000000000000000000000000000111111111111
11111111111111100000110000000000011000000000000000000011111111111
11111111111111000000000000000100111100000000000001100000111111111
11111111110000000000000000001110111110000000000000111000011111111
11111111000000000000000000011111111100000000000000011110001111111
11111110000000011111111111111111111100000000000000001111100111111
11111111000001111111111111111111110000000000000000001111111111111
11111111110111111111111111111100000000000000000000000111111111111
11111111111111110000000000000000000000000000000000000111111111111
11111111111111111100000000000000000000000000001100000111111111111
11111111111111000000000000000000000000000000111100000111111111111
11111111111000000000000000000000000000000001111110000111111111111
11111111100000000000000000000000000000001111111110000111111111111
11111110000000000000000000000000000000111111111110000111111111111
11111100000000000000000001110000001111111111111110001111111111111
11111000000000000000011111111111111111111111111110011111111111111
11110000000000000001111111111111111100111111111111111111111111111
11100000000000000011111111111111111111100001111111111111111111111
11100000000001000111111111111111111111111000001111111111111111111
11000000000001100111111111111111111111111110000000111111111111111
11000000000000111011111111111100011111000011100000001111111111111
11000000000000011111111111111111000111110000000000000011111111111
11000000000000000011111111111111000000000000000000000000111111111
11001000000000000000001111111110000000000000000000000000001111111
11100110000000000001111111110000000000000000111000000000000111111
11110110000000000000000000000000000000000111111111110000000011111
11111110000000000000000000000000000000001111111111111100000001111
11111110000010000000000000000001100000000111011111111110000001111
11111111000111110000000000000111110000000000111111111110110000111
11111110001111111100010000000001111100000111111111111111110000111
11111110001111111111111110000000111111100000000111111111111000111
11111111001111111111111111111000000111111111111111111111111100011
*/