#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;

inline int rd() {
    int x = 0;
    bool f = 0;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) f |= (c == '-');
    for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
    return f ? -x : x;
}

#define eb emplace_back
#define all(s) (s).begin(), (s).end()
#define rep(i, a, b) for (int i = (a); i <= (b); ++i)
#define per(i, a, b) for (int i = (a); i >= (b); --i)

constexpr int N = (1 << 11);
constexpr int mod = 998244353;

int a[N][N], b[N][N], c[N][N], testcase;

ll A[N], B[N], C[N], lst[N];

void FWT(ll *a, int n, int f) {
    for (int k = 1; k < n; k <<= 1)
        for (int i = 0; i < n; i += (k << 1))
            for (int j = 0; j < k; ++j) {
                if (f == 1) {
                    ll x = a[i + j];
                    ll y = a[i + j + k];
                    a[i + j] = x + y;
                    a[i + j + k] = x - y;
                } else {
                    ll x = a[i + j];
                    ll y = a[i + j + k];
                    a[i + j] = (x + y) / 2;
                    a[i + j + k] = (x - y) / 2;
                }
            }
}

inline void work() {
    memset(a, 0, sizeof(a));
    memset(b, 0, sizeof(b));
    memset(c, 0, sizeof(c));
    memset(lst, 0, sizeof(lst));
    int a1 = rd(), b1 = rd(), c1 = rd();
    int a2 = rd(), b2 = rd(), c2 = rd();
    rep(i, 0, a1) rep(j, 0, a2) a[abs(i - j)][i ^ j]++;
    rep(i, 0, b1) rep(j, 0, b2) b[abs(i - j)][i ^ j]++;
    rep(i, 0, c1) rep(j, 0, c2) c[abs(i - j)][i ^ j]++;

    ull ans = 0;
    rep(k, 0, 2000) {
        if (k) {
            rep(w, 0, N - 1) {
                a[k][w] += a[k - 1][w];
                b[k][w] += b[k - 1][w];
                c[k][w] += c[k - 1][w];
            }
        }
        rep(w, 0, N - 1) {
            A[w] = a[k][w];
            B[w] = b[k][w];
            C[w] = c[k][w];
        }
        FWT(A, N, 1); FWT(B, N, 1); FWT(C, N, 1);
        rep(w, 0, N - 1) A[w] = A[w] * B[w] * C[w];
        FWT(A, N, -1);
        rep(w, 0, N - 1) {
            ull num = A[w] - lst[w];
            ans += (k ^ w) * num;
        }
        rep(w, 0, N - 1) lst[w] = A[w];
    }
    printf("Case #%d: %llu\n", ++testcase, ans);
}

int main() {
    per(t, rd(), 1) work();
    return 0;
}