#include <bits/stdc++.h>

using i64 = long long;

template <class T, class G>
struct BaseVector2 {
    T x, y;
    constexpr BaseVector2() : BaseVector2(T{}, T{}) {}
    constexpr BaseVector2(T x, T y) : x{x}, y{y} {}

    // 运算
    constexpr BaseVector2 operator+(BaseVector2 a) const {
        return BaseVector2(x + a.x, y + a.y);
    }
    constexpr BaseVector2 operator-(BaseVector2 a) const {
        return BaseVector2(x - a.x, y - a.y);
    }
    constexpr BaseVector2 operator-() const {
        return BaseVector2(-x, -y);
    }
    constexpr G operator*(BaseVector2 a) const {
        return G(x) * a.x + G(y) * a.y;
    }
    constexpr G operator%(BaseVector2 a) const {
        return G(x) * a.y - G(y) * a.x;
    }
    constexpr BaseVector2 rotate() const {
        return BaseVector2(-y, x);
    }
    template <class Float>
    constexpr BaseVector2 rotate(Float theta) const {
        BaseVector2 b(cosl(theta), sinl(theta));
        return BaseVector2(x * b.x - y * b.y,
                           x * b.y + y * b.x);
    }
    constexpr friend BaseVector2 operator*(const T &a, BaseVector2 b) {
        return BaseVector2(a * b.x, a * b.y);
    }

    // 比较
    constexpr bool operator<(BaseVector2 a) const {
        if (x == a.x) {
            return y < a.y;
        }
        return x < a.x;
    }

    constexpr bool operator>(BaseVector2 a) const {
        if (x == a.x) {
            return y > a.y;
        }
        return x > a.x;
    }

    constexpr bool operator<=(BaseVector2 a) const {
        if (x == a.x) {
            return y <= a.y;
        }
        return x <= a.x;
    }

    constexpr bool operator>=(BaseVector2 a) const {
        if (x == a.x) {
            return y >= a.y;
        }
        return x >= a.x;
    }

    constexpr bool operator==(BaseVector2 a) const {
        return x == a.x and y == a.y;
    }

    constexpr bool operator!=(BaseVector2 a) const {
        return x != a.x or y != a.y;
    }

    // 输入输出
    friend std::istream &operator>>(std::istream &in, BaseVector2 &p) {
        return in >> p.x >> p.y;
    }
    friend std::ostream &operator<<(std::ostream &ot, BaseVector2 p) {
        return ot << '(' << p.x << ", " << p.y << ')';
    }
};

template <class T, class G>
G dis2(BaseVector2<T, G> a, BaseVector2<T, G> b = BaseVector2<T, G>(0, 0)) {
    BaseVector2<T, G> p = a - b;
    return p * p;
}
template <class T, class G>
auto dis(BaseVector2<T, G> a, BaseVector2<T, G> b = BaseVector2<T, G>(0, 0)) {
    return sqrtl(dis2(a, b));
}

template <class T, class G>
int sgn(BaseVector2<T, G> p) {
    if (p.x < 0 or p.x == 0 and p.y > 0) {
        return 1;
    } else
        return 0;
    // 以41象限为先
}

template <class Vector>
bool polarCmp(Vector p, Vector q) {
    if (sgn(p) == sgn(q)) {
        if (p % q == 0) {
            return dis2(p) < dis2(q);
        } else {
            return p % q > 0;
        }
    } else {
        return sgn(p) < sgn(q);
    }
}

using Point = BaseVector2<int, i64>;
using Vector = Point;
using PS = std::vector<Point>;

void solve() {
    int n;
    std::cin >> n;

    std::vector<int> w(n * 2);
    for (int i = 0; i < n; i++) {
        std::cin >> w[i];
        w[i + n] = w[i];
    }

    PS ps(n * 2);
    for (int i = 0; i < n; i++) {
        std::cin >> ps[i];
        ps[i + n] = ps[i];
    }

    constexpr i64 Inf = ((1LL << 62) - 1) * 2;
    std::vector f(n * 2, std::vector(n * 2, std::array<i64, 3>{-Inf, -Inf, -Inf}));
    for (int i = 0; i < n * 2; i++) {
        f[i][i][0] = 0;

        int j = i + 1;
        if (j < n * 2) {
            if (w[i] == w[j]) {
                f[i][j] = {0, 0, 0};
            } else {
                f[i][j] = {-Inf, 0, 0};
            }
        }
    }

    i64 ans = 0;
    for (int len = 3; len <= n; len++) {
        for (int l = 0; l < n * 2; l++) {
            int r = l + len - 1;
            if (r >= n * 2) {
                continue;
            }

            for (int k = l + 1; k < r; k++) {
                i64 S = ps[l] % ps[k] + ps[k] % ps[r] + ps[r] % ps[l];
                if (w[l] == w[r]) {
                    f[l][r][0] = std::max({f[l][r][0], f[l][k][1] + S, f[k][r][2] + S});
                }

                if (w[l] == w[k]) {
                    f[l][r][2] = std::max(f[l][r][2], f[l][k][0] + S);
                }

                if (w[r] == w[k]) {
                    f[l][r][1] = std::max(f[l][r][1], f[k][r][0] + S);
                }
            }

            ans = std::max(ans, f[l][r][0]);
        }
    }

    std::cout << ans << '\n';
    return;
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}