#include <bits/stdc++.h>

#include <algorithm>
#include <queue>

#ifdef LOCAL
#include "debug.h"
#else
#define deb(...) 114514
#endif

using namespace std;

using LL = long long;
using pii = pair<int, int>;
using pll = pair<LL, LL>;
const int INF = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
const int N = 3e5 + 10;

class DSU {
public:
    std::vector<int> d;
    DSU(std::size_t size) : d(size + 1) {
        std::iota(d.begin(), d.end(), 0);
    }
    int root(int u) {
        return d[u] == u ? u : d[u] = root(d[u]);
    }
    void bind(int u, int v) {
        d[root(u)] = root(v);
    }
};

void solve() {
    int n, l, q;
    cin >> n >> l >> q;
    DSU dsu(n);
    vector<vector<array<int, 2>>> gra(n + 1);
    for (int i = 1; i <= l; i++) {
        string s;
        cin >> s;
        vector<int> to(n + 1);
        vector<array<int, 2>> fa(n + 1);
        vector<char> vis(n + 1);
        bool ok = 1;
        int p = 0;
        for (int j = 0; j < 2 * n; j += 2) {
            int u = j / 2 + 1;
            int v = (s[j] - 48) * 50 + (s[j + 1] - 48);
            to[u] = v;
            if (!fa[v][0])
                fa[v][0] = u;
            else if (!fa[v][1]) {
                fa[v][1] = u;
                if (!p)
                    p = v;
                else
                    ok = 0;
            } else
                ok = 0;
        }
        if (!ok)
            continue;
        if (p) {
            int empty = min_element(fa.begin() + 1, fa.end()) - fa.begin();
            gra[fa[p][0]].push_back({empty, i});
            gra[fa[p][1]].push_back({empty, i});
            int v = fa[p][0];
            while (v && !vis[v]) {
                vis[v] = 1;
                v = fa[v][0];
            }
            v = fa[p][1];
            while (v && !vis[v]) {
                vis[v] = 1;
                v = fa[v][0];
            }
        }
        for (int j = 1; j <= n; j++) {
            if (!vis[j]) {
                vis[j] = 1;
                int v = to[j];
                while (v != j) {
                    vis[v] = 1;
                    if (n <= 10 || dsu.root(j) != dsu.root(v)) {
                        gra[j].push_back({v, i}), gra[v].push_back({j, i});
                        dsu.bind(j, v);
                    }
                    v = to[v];
                }
            }
        }
    }
    vector<vector<int>> dis(n + 1, vector<int>(n + 1, INF));
    for (int i = 1; i <= n; i++) {
        priority_queue<array<int, 2>, vector<array<int, 2>>, greater<>> que;
        que.push({0, i});
        vector<char> vis(n + 1);
        dis[i][i] = 0;
        while (que.size()) {
            auto [dist, u] = que.top();
            que.pop();
            if (vis[u])
                continue;
            vis[u] = 1;
            for (auto [v, t] : gra[u]) {
                if (dis[i][v] > max(dist, t)) {
                    dis[i][v] = max(dist, t);
                    que.push({max(dist, t), v});
                }
            }
        }
    }
    // deb(gra);
    while (q--) {
        string s;
        cin >> s;
        int u = (s[0] - 48) * 50 + s[1] - 48;
        int v = (s[2] - 48) * 50 + s[3] - 48;
        int t = (s[4] - 48) * 50 + s[5] - 48;
        if (dis[u][v] <= t) {
            cout << 1;
        } else {
            cout << 0;
        }
    }
    cout << '\n';
}

signed main() {
#ifdef LOCAL
    clock_t tttttttt = clock();
    freopen("in.txt", "r", stdin);
#endif
#ifndef LOCAL
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#endif
    //*****************************************************************
    int t = 1;
    cin >> t;
    while (t--) solve();
//*****************************************************************
#ifdef LOCAL
    cerr << "Time Used: " << fixed << setprecision(3) << (clock() - tttttttt) / (CLOCKS_PER_SEC / 1000.0) << " ms" << endl;
#endif
    return 0;
}