#include <bits/stdc++.h>
using namespace std;

struct Tarjan {
    static const int MAXN = 1000 + 10;
    vector<int> SCC[MAXN];
    int low[MAXN], dfn[MAXN], stk[MAXN], col[MAXN];
    int scc_cnt, sz, top;
    void dfs(int x, vector<int> G[]) {
        low[x] = dfn[x] = ++ sz; stk[++ top] = x;
        for (int i = 0, y; i < (int)G[x].size(); ++ i) {
            if (!dfn[y = G[x][i]]) {
                dfs(y, G); low[x] = min(low[x], low[y]);
            }
            else if (col[y] == -1) low[x] = min(low[x], dfn[y]);
        }
        if (dfn[x] == low[x]) {
            SCC[scc_cnt ++].clear();
            do {
                SCC[scc_cnt - 1].push_back(stk[top]);
                col[stk[top]] = scc_cnt - 1;
            } while (stk[top --] != x);
        }
    }
    void solve(int n, vector<int> G[]) {
        sz = top = scc_cnt = 0;
        memset(dfn, 0, sizeof(dfn));
        memset(col, -1, sizeof(col));
        for (int i = 0; i < n; ++ i)
            if (!dfn[i]) dfs(i, G);
    }
} Task;

const int MAXN = 1000 + 24;

vector<int> G[MAXN], Gr[MAXN];
bitset<MAXN> reach[MAXN];
int deg[MAXN], n, m;

void build() {
    for (int i = 0; i < m; ++ i) {
        Gr[i].clear(); deg[i] = 0;
        reach[i].reset(); reach[i][i] = 1;
    }
    for (int i = 0; i < n; ++ i) {
        for (int j = 0; j < (int)G[i].size(); ++ j) {
            int u = Task.col[i], v = Task.col[G[i][j]];
            if (u == v) continue;
            Gr[u].push_back(v); ++ deg[v];
        }
    }
}

double solve() {
    queue<int> Q;
    for (int i = 0; i < m; ++ i) {
        if (deg[i] == 0) Q.push(i);
    }
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        for (int i = 0; i < (int)Gr[u].size(); ++ i) {
            int v = Gr[u][i]; deg[v] --;
            if (deg[v] == 0) Q.push(v);
            reach[v] |= reach[u];
        }
    }
    double ret = 0;
    for (int i = 0; i < m; ++ i) {
        int cnt = 0;
        for (int j = 0; j < m; ++ j) {
            if (reach[i][j]) cnt += Task.SCC[j].size();
        }
        ret += 1.0 * Task.SCC[i].size() / cnt;
    }
    return ret;
}

int main() {
    int T; scanf("%d", &T);
    for (int cas = 1; cas <= T; ++ cas) {
        scanf("%d", &n);
        for (int i = 0, k; i < n; ++ i) {
            G[i].clear();
            for (scanf("%d", &k); k --; ) {
                int x; scanf("%d", &x);
                G[i].push_back(x - 1);
            }
        }
        Task.solve(n, G);
        m = Task.scc_cnt;
        build();
        printf("Case #%d: %.5f\n", cas, solve());
    }
    return 0;
}