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

int readInt() {
    char a, b;
    cin >> a >> b;
    return (a-'0')*50 + (b-'0');
}

void solve() {
    int N, L, Q;
    cin >> N >> L >> Q;
    vector<vector<int>> g(N), G(N);
    auto addedge = [&](int u, int v) {
        // cout << u << " " << v << endl;
        g[u].push_back(v);
        G[v].push_back(u);
    };
    constexpr int N_ = 2000;
    auto compute = [&]() {
        vector<int> scc(N);
        vector<vector<int>> bel;
        vector<int> dfn(N, -1), low(N), ins(N), stk;
        int timer = 0;
        // cout << "SS0" << endl;
        auto dfs = [&](auto &dfs, int u) -> void {
            dfn[u] = low[u] = timer++;
            ins[u] = true;
            stk.push_back(u);
            for (auto v : g[u]) {
                if (dfn[v] == -1) {
                    dfs(dfs, v);
                    // low[u] = min(low[u], dfn[v]);
                }
                if (ins[v]) {
                    low[u] = min(low[u], low[v]);
                }
            }
            if (low[u] == dfn[u]) {
                int cnt = bel.size();
                bel.push_back({});
                while (!stk.empty()) {
                    int v = stk.back();
                    stk.pop_back();
                    scc[v] = cnt;
                    bel[cnt].push_back(v);
                    ins[v] = false;
                    if (u == v) {
                        break;
                    }
                }
            }
        };
        for (int i = 0; i < N; i++) {
            if (dfn[i] == -1) {
                dfs(dfs, i);
            }
        }
        // cout << "SS1" << endl;
        vector<bitset<N_>> bs(bel.size());
        for (int i = 0; i < bel.size(); i++) {
            bs[i].set(i);
            for (auto u : bel[i]) {
                for (auto v : G[u]) {
                    if (scc[u] != scc[v]) {
                        bs[scc[v]] |= bs[i];
                    }
                }
            }
        }
        // cout << "SS2" << endl;
        return make_pair(bs, scc);
    };

    vector<int> fa(N);
    iota(fa.begin(), fa.end(), 0);
    auto getP = [&](auto &find, int u) {
        if (u == fa[u]) {
            return u;
        }
        return fa[u] = find(find, fa[u]);
    };
    vector<vector<pair<int, int>>> upd(L + 1);
    for (int i = 1; i <= L; ++i) {
        vector<vector<int>> deg(N);
        for (int a, j = 0; j < N; ++j) {
            a = readInt() - 1;
            deg[a].push_back(j);
        }
        vector<int> deg0, deg1, deg2;
        for (int j = 0; j < N; ++j) {
            if (deg[j].size() == 0) deg0.push_back(j);
            else if (deg[j].size() == 1) deg1.push_back(j);
            else if (deg[j].size() == 2) deg2.push_back(j);
        }
        if (deg1.size() == N) {
            // perm
            // merge
            vector<pair<int, int>> toAdd;
            for (int j = 0; j < N; ++j) {
                int u = deg[j][0], v = j;
                if (getP(getP, u) != getP(getP, v)) {
                    // fa[getP(getP, u)] = getP(getP, v);
                    upd[i].push_back({u, v});
                    toAdd.push_back({u, v});
                }
            }
            for (auto [u, v] : toAdd) {
                fa[getP(getP, u)] = getP(getP, v);
            }
        } else if (deg0.size() == 1 && deg1.size() == N-2 && deg2.size() == 1) {
            upd[i].push_back({deg[deg2[0]][0], deg0[0]});
            upd[i].push_back({deg[deg2[0]][1], deg0[0]});
        }
    }
    vector<vector<array<int, 3>>> queries(L+1);
    for (int i = 0; i < Q; ++i) {
        int a = readInt(), b = readInt(), c = readInt();
        // cout << a << " " << b << " " << c << endl;
        queries[c].push_back({i, a-1, b-1});
    }
    vector<int> ans(Q);
    for (int i = 0; i <= L; ++i) {
        for (auto [u, v] : upd[i]) addedge(u, v);
        auto [bs, scc] = compute();
        // cout << "SCC ";
        // for (auto u : scc) cout << u << ' ';
        // cout << '\n';
        for (auto [j, a, b] : queries[i]) {
            // assert(0 <= a && a < N);
            // assert(0 <= b && b < N);
            // cout << a << " " << b << " " << bs[scc[a]][scc[b]] << endl;
            ans[j] = bs[scc[a]][scc[b]];
        }
    }
    for (int i = 0; i < Q; ++i) cout << ans[i];
    cout << "\n";
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    int TT; cin >> TT;
    while (TT--) {
        solve();
    }
}