#include <bits/stdc++.h>

constexpr int mod = 1e9 + 7;

int add(int a, int b) {
    return a + b - mod * (a + b >= mod);
}
void add_to(int& a, int b) {
    a = add(a, b);
}
int mul(int a, int b) {
    return a * 1ULL * b % mod;
}
int power(int b, int e) {
    int r = 1;
    for (; e > 0; e >>= 1) {
        if (e & 1)
            r = mul(r, b);
        b = mul(b, b);
    }
    return r;
}

//

int group_id;

void solve() {
    int n, m, k;
    std::cin >> n >> m >> k;
    std::vector<int> prev(n, -1);
    for (int i = 1; i < n; i++) {
        std::cin >> prev[i];
        prev[i]--;
    }

    if (m == 0) {
        std::cout << 1 << "\n";
        return;
    }
    if (m == 1) {
        std::cout << 2 * n - 1 << "\n";
        return;
    }

    std::vector<std::vector<int>> init_lca(n, std::vector<int>(n));
    {
        std::vector<std::vector<int>> gr(n);
        for (int i = 1; i < n; i++) {
            gr[prev[i]].push_back(i);
        }
        std::vector<int> depth(n), prv(n), jmp(n);
        auto dfs = [&](auto dfs, int v, int f) -> void {
            prv[v] = f;
            jmp[v] = f;
            if (depth[v] > 1 && depth[f] + depth[jmp[jmp[f]]] == 2 * depth[jmp[f]]) {
                jmp[v] = jmp[jmp[f]];
            }
            for (int t : gr[v]) {
                if (t != f) {
                    depth[t] = depth[v] + 1;
                    dfs(dfs, t, v);
                }
            }
        };
        dfs(dfs, 0, 0);

        auto jump = [&](int v, int d) {
            while (depth[v] > d) {
                v = (depth[jmp[v]] >= d ? jmp[v] : prv[v]);
            }
            return v;
        };
        auto get_lca = [&](int u, int v) {
            if (depth[u] < depth[v]) {
                std::swap(u, v);
            }
            u = jump(u, depth[v]);
            while (u != v) {
                if (jmp[u] != jmp[v]) {
                    u = jmp[u], v = jmp[v];
                } else {
                    u = prv[u], v = prv[v];
                }
            }
            return u;
        };
        auto get_dist = [&](int u, int v) {
            return depth[u] + depth[v] - 2 * depth[get_lca(u, v)];
        };
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                init_lca[i][j] = init_lca[j][i] = get_lca(i, j);
            }
        }
    }

    int ans = 0;
    prev.resize(n + m);
    auto fuck = [&](auto fuck, int i) {
        if (i == n + m) {
            for (int j = 1; j < n + m; j++) {
                int v = j;
                for (int k = 0; v != -1 && k < n + m; k++) {
                    v = prev[v];
                }
                if (v != -1) {
                    return;
                }
            }

            std::vector<std::vector<int>> gr(n + m);
            for (int i = 1; i < n + m; i++) {
                gr[prev[i]].push_back(i);
            }
            std::vector<int> depth(n + m), prv(n + m), jmp(n + m);
            auto dfs = [&](auto dfs, int v, int f) -> void {
                prv[v] = f;
                jmp[v] = f;
                if (depth[v] > 1 && depth[f] + depth[jmp[jmp[f]]] == 2 * depth[jmp[f]]) {
                    jmp[v] = jmp[jmp[f]];
                }
                for (int t : gr[v]) {
                    if (t != f) {
                        depth[t] = depth[v] + 1;
                        dfs(dfs, t, v);
                    }
                }
            };
            dfs(dfs, 0, 0);

            auto jump = [&](int v, int d) {
                while (depth[v] > d) {
                    v = (depth[jmp[v]] >= d ? jmp[v] : prv[v]);
                }
                return v;
            };
            auto get_lca = [&](int u, int v) {
                if (depth[u] < depth[v]) {
                    std::swap(u, v);
                }
                u = jump(u, depth[v]);
                while (u != v) {
                    if (jmp[u] != jmp[v]) {
                        u = jmp[u], v = jmp[v];
                    } else {
                        u = prv[u], v = prv[v];
                    }
                }
                return u;
            };
            auto get_dist = [&](int u, int v) {
                return depth[u] + depth[v] - 2 * depth[get_lca(u, v)];
            };

            bool suc = true;
            for (int i = 0; i < n && suc; i++) {
                for (int j = i + 1; j < n; j++) {
                    if (get_lca(i, j) != init_lca[i][j]) {
                        suc = false;
                        break;
                    }
                }
            }
            for (int i = 0; i < n + m && suc; i++) {
                for (int j = 0; j < n + m; j++) {
                    if (get_lca(i, j) > std::max(i, j) + k) {
                        suc = false;
                        break;
                    }
                }
            }
            ans += suc;
            return;
        }
        for (int j = 0; j < n + m; j++) {
            if (i == j) {
                continue;
            }
            prev[i] = j;
            fuck(fuck, i + 1);
        }
    };

    fuck(fuck, 1);

    std::cout << ans << "\n";
}

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> group_id >> t;
    while (t--) {
        solve();
    }

    return 0;
}