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

struct DSU {
    vector<int> f, siz;
    
    DSU() {}
    DSU(int n) {
        init(n);
    }
    
    void init(int n) {
        f.resize(n + 1);
        iota(f.begin(), f.end(), 0);
        siz.assign(n + 1, 1);
    }
    
    int find(int x) {
        while (x != f[x]) {
            x = f[x] = f[f[x]];
        }
        return x;
    }
    
    bool same(int x, int y) {
        return find(x) == find(y);
    }
    
    bool merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) {
            return false;
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }
    
    int size(int x) {
        return siz[find(x)];
    }
};

struct Info {
    int cur = 0;
    int mx = -1e9;
    friend bool operator < (Info a, Info b) {
        return a.mx > b.mx;
    }
};

int cal(char x, char y) {
    return (x - 48) * 50 + y - 48;
}

void solve() {
    int n, l, q;
    cin >> n >> l >> q;
    vector to(l + 1, vector<int>(n + 1));
    vector inv(l + 1, vector<int>(n + 1));
    vector<vector<pair<int, int>>> adj(n + 1);
    DSU dsu(n);
    for (int i = 1; i <= l; i++) {
        string s;
        cin >> s;
        vector<int> vis(n + 1);
        for (int j = 0, k = 1; j < s.size(); j += 2, k++) {
            to[i][k] = cal(s[j], s[j + 1]);
            inv[i][to[i][k]] = k;
            vis[to[i][k]] = 1;
        }
        int cnt = accumulate(vis.begin() + 1, vis.end(), 0);
        if (cnt == n) {
            for (int j = 1; j <= n; j++) {
                if (!dsu.same(j, to[i][j])) {
                    adj[j].emplace_back(to[i][j], i);
                    adj[to[i][j]].emplace_back(j, i);
                    dsu.merge(j, to[i][j]);
                }
            }
        } else if (cnt == n - 1) {
            int x = 0;
            vis.assign(n + 1, 0);
            for (int j = 1; j <= n; j++) {
                if (vis[to[i][j]]) {
                    x = to[i][j];
                    break;
                }
                vis[to[i][j]] = 1;
            }
            vector<int> a;
            for (int j = 1; j <= n; j++) {
                if (to[i][j] == x) {
                    a.emplace_back(j);
                }
            }
            assert(a.size() == 2);
            // 初始只能在 a[0] 或者 a[1]，其结果都是唯一确定的，把对应的几个点 merge 一下就行了

            auto dfs = [&](auto self, int u, int fa, int t) -> void {
                if (vis[u]) {
                    // cout << "edge = " << t << ' ' << fa << endl;
                    adj[t].emplace_back(fa, i);
                    return;
                }
                vis[u] = 1;
                self(self, inv[i][u], u, t);
            };
            vis.assign(n + 1, 0);
            vis[0] = 1;
            inv[i][x] = a[1];
            dfs(dfs, a[0], a[0], a[0]);
            vis.assign(n + 1, 0);
            vis[0] = 1;
            inv[i][x] = a[0];
            dfs(dfs, a[1], a[1], a[1]);
            // 注意是单向边！！！
        }
    }
    vector<vector<tuple<int, int, int>>> qry(n + 1);
    vector<int> ans(q);

    for (int i = 0; i < q; i++) {
        string s;
        cin >> s;
        int a = cal(s[0], s[1]);
        int b = cal(s[2], s[3]);
        int c = cal(s[4], s[5]);
        // cout << a << ' ' << b << ' ' << c << endl;
        qry[a].emplace_back(b, c, i);
    }

    priority_queue<Info> Q;
    for (int i = 1; i <= n; i++) {
        vector<int> d(n + 1, -1);
        Q.emplace(i, 0);
        while (!Q.empty()) {
            auto [u, mx] = Q.top();
            Q.pop();
            if (d[u] != -1) continue;  
            d[u] = mx;
            for (auto [v, w] : adj[u]) {
                Q.emplace(v, max(mx, w));
            }
        }
        for (auto [b, c, idx] : qry[i]) {
            if (d[b] != -1 && d[b] <= c) {
                ans[idx] = 1;
            }
        }
    }

    for (int i = 0; i < q; i++) {
        cout << ans[i];
    }
    cout << "\n";

}   

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    int t = 1;
    cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}