#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

// 整数幾何
typedef ll Integer;
const Integer eps = 0;
inline constexpr int arg_type(Integer x, Integer y) { return y < 0 ? 2 : x < 0 ? 1 : 0; }
struct Point {
    Integer x, y;
    constexpr explicit Point(Integer x = 0, Integer y = 0) : x(x), y(y) {}
    constexpr Point operator+() const noexcept { return *this; }
    constexpr Point operator-() const noexcept { return Point(-x, -y); }
    constexpr Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
    constexpr Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
    constexpr Point &operator+=(const Point &p) { return x += p.x, y += p.y, *this; }
    constexpr Point &operator-=(const Point &p) { return x -= p.x, y -= p.y, *this; }
    constexpr Point &operator*=(const Integer &k) { return x *= k, y *= k, *this; }
    constexpr Point operator*(const Integer &k) const { return Point(x * k, y * k); }
    constexpr bool operator==(const Point &r) const noexcept { return r.x == x and r.y == y; }
    constexpr Integer dot(const Point &r) const { return x * r.x + y * r.y; }
    constexpr Integer cross(const Point &r) const { return x * r.y - y * r.x; }
    constexpr Integer norm2() const { return x * x + y * y; }
};

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q;
    cin >> q;
    auto area = [&](Point a, Point b, Point c) -> ll {
        b -= a, c -= a;
        ll bx = b.x, by = b.y, cx = c.x, cy = c.y;
        return abs(bx * cy - cx * by);
    };
    while (q--) {
        int n, m;
        cin >> n;
        vector<int> v(n);
        for (int i = 0; i < n; ++i) {
            cin >> v[i];
        }
        {
            auto z = v;
            sort(z.begin(), z.end());
            z.erase(unique(z.begin(), z.end()), z.end());
            m = z.size();
            for (int i = 0; i < n; ++i) {
                v[i] = lower_bound(z.begin(), z.end(), v[i]) - z.begin();
            }
        }
        vector<Point> p(n);
        for (int i = 0; i < n; ++i) {
            cin >> p[i].x >> p[i].y;
        }

        ll res = 0;
        vector<vector<int>> nxt_r(n);
        for (int i = 0; i < n; ++i) {
            nxt_r[i].resize(m);
            std::fill(nxt_r[i].begin(), nxt_r[i].end(), -1);
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0, k = i; j < n; ++j) {
                k -= 1;
                if (k == -1) k = n - 1;
                if (k == i) break;
                nxt_r[k][v[i]] = i;
                if (v[k] == v[i]) break;
            }
        }
        vector<vector<ll>> dp(n, vector<ll>(n, -1));
        auto get_idx = [&](int l, int d) -> int {
            l += d;
            if (l >= n) l -= n;
            return l;
        };
        auto calc = [&](auto calc, int l, int d) -> ll {
            if (dp[l][d] != -1) {
                return dp[l][d];
            }
            dp[l][d] = 0;
            int r = get_idx(l, d);
            int nxt_l = l;
            for (int i = 1; i + d < n; ++i) {
                nxt_l -= 1;
                if (nxt_l == -1) nxt_l = n - 1;
                int uo = nxt_r[r][v[nxt_l]];
                if (uo == -1) continue;
                int cnt = uo - r;
                if (cnt < 0) cnt += n;
                if (cnt + i + d >= n) continue;
                ll add = 0;
                if (d == 0) {
                    add = area(p[l], p[nxt_l], p[uo]);
                } else {
                    add = area(p[l], p[r], p[uo]);
                    add += area(p[nxt_l], p[uo], p[l]);
                }
                dp[l][d] = max(dp[l][d], calc(calc, nxt_l, cnt + i + d) + add);
            }
            return dp[l][d];
        };
        for (int i = 0; i < n; ++i) {
            res = max(res, calc(calc, i, 0));
            for (int j = 0; j < n; ++j) {
                if (i == j or v[i] != v[j]) continue;
                int len = j - i;
                if (len < 0) len += n;
                res = max(res, calc(calc, i, len));
            }
        }
        cout << res << "\n";
    }
}