#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;

int N;
int P[10];
long long dp[1 << 8][30]; // dp[mask][points_of_last_team]

void solve() {
    int case_idx = 1;
    while (cin >> N && N != 0) {
        for (int i = 0; i < N; ++i) cin >> P[i];
        sort(P, P + N, greater<int>()); // Sắp xếp để giảm số lượng trạng thái điểm số cần xét

        // Khởi tạo DP
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1;

        // Duyệt qua các mask
        for (int mask = 0; mask < (1 << N) - 1; ++mask) {
            int k = __builtin_popcount(mask); // Số đội đã được xét
            int next_team_idx = k; // Đội tiếp theo sẽ được thêm vào (theo index trong mảng đã sort)

            // Chỉ xét các trạng thái hợp lệ
            for (int p_last = 0; p_last <= 3 * k; ++p_last) {
                if (dp[mask][p_last] == 0) continue;

                // Lấy các bit chưa set
                int remaining_mask = ((1 << N) - 1) ^ mask;
                for (int i = 0; i < N; ++i) {
                    if ((remaining_mask >> i) & 1) {
                        // Thử các kết quả giữa team next_team_idx và team i
                        // Lưu ý: team i là index trong mảng P gốc, next_team_idx là index mới
                        // Thực ra logic này cần cẩn thận: DP thường thêm 1 team vào mỗi bước.
                        // Ở đây chúng ta cần chèn team tiếp theo vào set các team đã xét.

                        // Logic chuẩn của approach này:
                        // Tại mỗi bước, ta có k team trong mask, có tổng điểm là sum(P[mask]).
                        // Ta thêm team có index k (trong mảng P đã sort) vào.
                        // Team này đấu với k team cũ.

                        // Tuy nhiên, code này hơi khác: Nó duyệt các node chưa có trong mask để thêm vào.
                        // Nhưng để DP hoạt động đúng, ta cần xác định team mới là ai.
                        // Giả sử ta thêm team có index là __builtin_popcount(mask).

                        int new_team = __builtin_popcount(mask);
                        // Team new_team sẽ đấu với tất cả các team j đã có trong mask
                        // Điểm số của new_team phụ thuộc vào kết quả các trận đấu đó.

                        // VÌ SỢ RỐI, TÔI SẼ DÙNG CÁCH KHÁC: DUYỆT RECURSIVE CÓ MEMO (BACKTRACKING CÓ LƯU TRẠNG THÁI)
                        // NHƯNG ĐỂ RA ĐÚNG YÊU CẦU, CÁCH TỐI ƯU NHẤT VỚI N=8 LÀ BACKTRACKING THUẦN.
                    }
                }
            }
        }
    }
}
// Do độ phức tạp và ràng buộc N nhỏ, Backtracking thuần dễ hiểu và implement hơn nhiều.
// Tuy nhiên, tách riêng 2 approach: 1 là Backtracking, 2 là DP Subset nếu có thể.

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;

int n;
int p[10];
int mLeft[10]; // Số trận còn lại của mỗi đội
int res;
bool possiblePoint[10][30]; // Mảng tối ưu hóa: possiblePoint[k][x] = true nếu với k trận còn lại, có thể đạt điểm x
vector<pair<int, int>> match;

// Kiểm tra xem có thể đạt được điểm số p[team] với mLeft[team] trận còn lại không
bool okToCont(int team) {
    return (p[team] >= 0) && possiblePoint[mLeft[team]][p[team]];
}

void duyet(int index) {
    if (index == match.size()) {
        res++;
        return;
    }

    int t1 = match[index].first;
    int t2 = match[index].second;

    // Giảm số trận còn lại của 2 đội (vì đang xét trận này)
    mLeft[t1]--;
    mLeft[t2]--;

    // Trường hợp 1: t1 thắng t2 (t1 được 3 điểm)
    p[t1] -= 3;
    if (okToCont(t1) && okToCont(t2))
        duyet(index + 1);
    p[t1] += 3;

    // Trường hợp 2: t2 thắng t1 (t2 được 3 điểm)
    p[t2] -= 3;
    if (okToCont(t1) && okToCont(t2))
        duyet(index + 1);
    p[t2] += 3;

    // Trường hợp 3: Hòa (mỗi đội được 1 điểm)
    p[t1]--;
    p[t2]--;
    if (okToCont(t1) && okToCont(t2))
        duyet(index + 1);
    p[t1]++;
    p[t2]++;

    // Khôi phục số trận còn lại
    mLeft[t1]++;
    mLeft[t2]++;
}

int main() {
    int caseNum = 1;
    while (cin >> n && n != 0) {
        for (int i = 0; i < n; i++) {
            cin >> p[i];
        }

        // Xử lý mảng possiblePoint trước
        memset(possiblePoint, 0, sizeof(possiblePoint));
        // Duyệt số trận từ 0 đến n-1
        for (int k = 0; k <= n - 1; k++) {
            possiblePoint[k][0] = true; // 0 trận, 0 điểm
            // Với k trận, điểm có thể nhận được là: i*3 + (k-i)*1 = 2i + k
            // i là số trận thắng, k-i là số trận hòa
            for (int i = 0; i <= k; i++) {
                int score = 2 * i + k;
                if (score <= 3 * (n - 1)) possiblePoint[k][score] = true;
            }
        }

        // Tạo danh sách các trận đấu
        match.clear();
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                match.push_back({i, j});
            }
        }

        // Khởi tạo số trận còn lại cho mỗi đội
        for (int i = 0; i < n; i++) mLeft[i] = n - 1;

        res = 0;
        duyet(0);

        cout << "Case #" << caseNum++ << ": " << res << endl;
    }
    return 0;
}

// Approach này về cơ bản là Backtracking nhưng lưu lại các trạng thái đã duyệt
// để tránh duyệt lại. Trạng thái: (mask các trận đã diễn ra, điểm số các đội)
// Tuy nhiên, do số trận ít (max 28), và N nhỏ, Backtracking thường là đủ.
// Code tương tự Backtracking, nhưng có thể thêm Map/Memo để tối ưu.
// Tuy nhiên, với N=8, số lượng trường hợp trong Backtracking là khá nhỏ (dưới 10^6).
// Nên Backtracking thường là đủ.

// Code mẫu cho Backtracking có thể được giữ nguyên như Approach 2.
// Lưu ý: Nếu N tăng lên (ví dụ > 10), ta cần dùng DP on Subsets hoặc DP on Permutations.
// Với N=8, Approach 2 là tối ưu nhất về mặt implement và thời gian chạy thực tế.