#include <bits/stdc++.h>

struct Complex {

    double r, i;

    void clear() { r = i = 0.0; }

    Complex(double r = , double i = ): r(r), i(i) {}

    Complex operator + (const Complex &p) const { return Complex(r + p.r, i + p.i); }

    Complex operator - (const Complex &p) const { return Complex(r - p.r, i - p.i); }

    Complex operator * (const Complex &p) const { return Complex(r * p.r - i * p.i, r * p.i + i * p.r); }

};

const double pi = acos(-1.0);

const int N = 5e5 + ;

int n, limit, l, r[N];

void FFT(Complex *a, int n, int pd) {

    for (int i = ; i < n; i++)

        if (i < r[i])

            std::swap(a[i], a[r[i]]);

    for (int mid = ; mid < n; mid <<= ) {

        Complex wn(cos(pi / mid), pd * sin(pi / mid));

        for (int l = mid << , j = ; j < n; j += l) {

            Complex w(1.0, 0.0);

            for (int k = ; k < mid; k++, w = w * wn) {

                Complex u = a[k + j], v = w * a[k + j + mid];

                a[k + j] = u + v;

                a[k + j + mid] = u - v;

            }

        }

    }

    if (pd < )

        for (int i = ; i < n; i++)

            a[i] = Complex(a[i].r / n, a[i].i / n);

}

#define ll long long

int A[N], B[N], C[N];

ll cntA[N], cntB[N], cntC[N];

void init(int val) {

    for (int i = ; i <= val; i++)

        cntA[i] = cntB[i] = cntC[i] = ;

}

void solve1() {

    int val =  * std::max(A[n], std::max(B[n], C[n])) + ;

    for (int i = ; i <= val; i++)

        cntA[i] += cntA[i - ], cntB[i] += cntB[i - ], cntC[i] += cntC[i - ];

    ll ans = ;

    for (int i = ; i <= n; i++)

        for (int j = ; j <= n; j++) {

            int cur = A[i] + B[j];

            ans += cntC[val] - cntC[cur];

            cur = A[i] + C[j];

            ans += cntB[val] - cntB[cur];

            cur = B[i] + C[j];

            ans += cntA[val] - cntA[cur];

        }

    ans = 1LL * n * n * n - ans;

    assert(ans >= );

    printf("%lld\n", ans);

}

Complex a[N], b[N], c[N], res[N];

void solve2() {

    limit = , l = ;

    int val =  * std::max(A[n], std::max(B[n], C[n])) + ;

    while (limit <= val) limit <<= , l++;

    for (int i = ; i < limit; i++)

        r[i] = r[i >> ] >>  | ((i & ) << (l - ));

    for (int i = ; i < limit; i++)

        a[i] = Complex((double)cntA[i], 0.0), b[i] = Complex((double)cntB[i], 0.0), c[i] = Complex((double)cntC[i], 0.0);

    for (int i = ; i <= val; i++)

        cntA[i] += cntA[i - ], cntB[i] += cntB[i - ], cntC[i] += cntC[i - ];

    FFT(a, limit, ); FFT(b, limit, ); FFT(c, limit, );

    for (int i = ; i < limit; i++)

        res[i] = a[i] * b[i];

    FFT(res, limit, -);

    ll ans = ;

    for (int i = ; i < limit; i++) {

        ll temp = (ll)(res[i].r + 0.5);

        ans += (cntC[val] - cntC[i]) * temp;

    }

    for (int i = ; i < limit; i++)

        res[i] = b[i] * c[i];

    FFT(res, limit, -);

    for (int i = ; i < limit; i++) {

        ll temp = (ll)(res[i].r + 0.5);

        ans += (cntA[val] - cntA[i]) * temp;

    }

    for (int i = ; i < limit; i++)

        res[i] = a[i] * c[i];

    FFT(res, limit, -);

    for (int i = ; i < limit; i++) {

        ll temp = (ll)(res[i].r + 0.5);

        ans += (cntB[val] - cntB[i]) * temp;

    }

    ans = 1LL * n * n * n - ans;

    assert(ans >= );

    printf("%lld\n", ans);

}

int main() {

    int T;

    scanf("%d", &T);

    for (int kase = ; kase <= T; kase++) {

        scanf("%d", &n);

        int x = ;

        for (int i = ; i <= n; i++)

            scanf("%d", A + i), x = std::max(x, A[i]);

        for (int i = ; i <= n; i++)

            scanf("%d", B + i), x = std::max(x, B[i]);

        for (int i = ; i <= n; i++)

            scanf("%d", C + i), x = std::max(x, C[i]);

        init(N - );

        std::sort(A + , A +  + n);

        std::sort(B + , B +  + n);

        std::sort(C + , C +  + n);

        for (int i = ; i <= n; i++)

            cntA[A[i]]++, cntB[B[i]]++, cntC[C[i]]++;

        printf("Case #%d: ", kase);

        if (n <= ) solve1();

        else solve2();

    }

    return ;

}