#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep2(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define rrep2(i, a, b) for (int i = (int)(b) - 1; i >= (int)(a); --i)

#define all(v) begin(v), end(v)

using namespace std;

using ll = long long;

template<class T, class U> bool chmin(T& a, const U& b) { return a > b ? a = b, true : false; }
template<class T, class U> bool chmax(T& a, const U& b) { return a < b ? a = b, true : false; }


constexpr ll MOD = 1000000007;

ll fact[1000001], finv[1000001];

ll mod_pow(ll a, ll b) {
    ll res = 1;
    while (b) {
        if (b & 1) (res *= a) %= MOD;
        (a *= a) %= MOD;
        b >>= 1;
    }
    return res;
}

ll comb(int n, int r) {
    return fact[n] * finv[r] % MOD * finv[n - r] % MOD;
}

void solve();

int main() {
    fact[0] = 1;
    rep2 (i, 1, 1000001) fact[i] = fact[i - 1] * i % MOD;
    finv[1000000] = mod_pow(fact[1000000], MOD - 2);
    rrep2 (i, 1, 1000001) finv[i - 1] = finv[i] * i % MOD;

    int c, t; cin >> c >> t;
    rep (_, t) solve();
}

class UnionFind {
    vector<int> par;

public:
    UnionFind(int n) : par(n, -1) {}
    int find(int x) { return par[x] < 0 ? x : par[x] = find(par[x]); }
    int size(int x) { return -par[x]; }
    bool merge(int x, int y) {
        x = find(x); y = find(y);
        if (x == y) return false;
        if (par[x] > par[y]) swap(x, y);
        par[x] += par[y];
        par[y] = x;
        return true;
    }
    bool same(int x, int y) { return find(x) == find(y); }
};

void solve() {
    int N, M, K; cin >> N >> M >> K;
    vector<int> par(N, -1);
    rep2 (i, 1, N) cin >> par[i], --par[i];
    int ans = 0;
    vector<int> P(N + M, -1);
    auto calc = [&](auto&& self, int k) -> void {
        if (k != N + M) {
            UnionFind uf(N + M);
            rep2 (i, 1, k) uf.merge(i, P[i]);
            rep (i, N + M) {
                if (uf.same(k, i)) continue;
                P[k] = i;
                self(self, k + 1);
            }
            return;
        }
        {
            vector<int> par2(N, -1);
            rep2 (i, 1, N) {
                int p = P[i];
                while (p >= N) p = P[p];
                par2[i] = p;
            }
            if (par != par2) return;
        }
        vector<vector<int>> G2(N + M);
        rep2 (i, 1, N + M) G2[P[i]].push_back(i);
        {
            bool f = true;
            auto dfs = [&](auto&& self, int v) -> int {
                int cnt = 0, mn = v;
                for (auto c : G2[v]) {
                    int d = self(self, c);
                    chmin(mn, d);
                    if (d < v - K) ++cnt;
                }
                if (cnt >= 2) f = false;
                return mn;
            };
            dfs(dfs, 0);
            if (!f) return;
        }
        ++ans;
    };
    calc(calc, 1);
    cout << ans << endl;
}