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

#define ll long long
#define ull unsigned long long
#define MAXN 2005

vector<int> cinOneLine()
{
    vector<int> ans;
    string s;
    cin >> s;
    for (int i = 0; i < s.length(); i += 2)
    {
        ans.push_back((s[i] - 48) * 50 + (s[i + 1] - 48));
    }
    return ans;
}

bool isPermutation(const vector<int>& a)
{
    vector<bool> vis(a.size() + 1);
    for (auto x : a)
    {
        if(vis[x])
            return false;
        vis[x] = 1;
    }
    return true;
}
vector<pair<int, int>> getTwoToOne(const vector<int>& a)
{
    vector<pair<int, int>> ans;
    vector<int> vis(a.size() + 1);
    for (auto x : a)
    {
        vis[x]++;
    }
    for (int i = 1, tot = 0; i <= a.size(); i++)
    {
        tot += vis[i] == 0;
        if(tot > 1)
            return {};
    }
    vector<bool> nvis(a.size() + 1);
    for (int i = 1; i <= a.size(); i++)
    {
        if(vis[i])
            continue;
        int D = i;
        int x = i;
        int last = -1;
        while (!nvis[x])
        {
            nvis[x] = 1;
            last = x;
            x = a[x - 1];
        }
        int A = x;
        int B = last;
        x = i;
        while (a[x - 1] != A)
        {
            x = a[x - 1];
        }
        int C = x;
        assert(B != D);
        ans.push_back({B, D});
        if(C != D)
            ans.push_back({C, D});
        break;
    }
    return ans;
}

void solve()
{
    int n, l, q;
    cin >> n >> l >> q;
    vector<vector<int>> lt(l + 1);
    for (int i = 1; i <= l; i++)
    {
        lt[i] = cinOneLine();
    }
    vector<pair<array<int, 3>, int>> query(q);
    for (int i = 0; i < q; i++)
    {
        auto temp = cinOneLine();

        query[i].first = {temp[0], temp[1], temp[2]};
        query[i].second = i;
    }
    sort(query.begin(), query.end(), [&](const pair<array<int, 3>, int> &a, const pair<array<int, 3>, int> &b)
    { 
        return a.first[2] < b.first[2];
    });
    vector<bool> ans(q);

    vector<int> fa(n + 1);
    for (int i = 1; i <= n; i++)
    {
        fa[i] = i;
    }
    auto find = [&](auto self, int x) -> int
    {
        return fa[x] == x ? x : fa[x] = self(self, fa[x]);
    };
    auto unity = [&](int u, int v) -> void
    {
        if(find(find, u) != find(find, v))
            fa[find(find, u)] = find(find, v);
    };

    vector<pair<int, int>> edges;
    vector<vector<int>> adj(n + 1);
    vector<int> indegree(n + 1);
    vector<bitset<MAXN>> cango(n + 1);

    vector<int> scc(n + 1), sz;
    int tot;

    int nowl = 1;
    for (auto &[abc, id] : query)
    {
        auto [a, b, c] = abc;
        while (nowl <= c)
        {
            if(isPermutation(lt[nowl]))
            {
                for (int i = 0; i < n; i++)
                {
                    unity(i + 1, lt[nowl][i]);
                }
            }
            else
            {
                auto vt = getTwoToOne(lt[nowl]);
                for (auto &[u, v] : vt)
                {
                    edges.push_back({u, v});
                }
            }
            for (int i = 1; i <= n; i++)
            {
                adj[i].clear();
            }
            for (auto &[u, v] : edges)
            {
                adj[find(find, u)].push_back(find(find, v));
            }

            vector<int> dfsn(n + 1), low(n + 1);
            int dfsncnt = 0;
            stack<int> s;
            vector<bool> in_stack(n + 1);
            auto tarjan = [&](auto self, int cur) ->void
            {
                if(dfsn[cur])
                    return;
                dfsn[cur] = dfsn[dfsncnt] + 1, dfsncnt = cur;
                low[cur] = dfsn[cur];
                s.push(cur), in_stack[cur] = 1;
                for (int to : adj[cur])
                {
                    if(!dfsn[to])
                    {
                        self(self, to);
                        low[cur] = min(low[cur], low[to]);
                    }
                    else if(in_stack[to])
                    {
                        low[cur] = min(low[cur], dfsn[to]);
                    }
                }
                if(low[cur] == dfsn[cur])
                {
                    int sc = sz.size();
                    sz.push_back(0);
                    while (s.top() != cur)
                    {
                        scc[s.top()] = sc;
                        in_stack[s.top()] = 0, s.pop();
                        sz[sc]++;
                    }
                    scc[s.top()] = sc;
                    in_stack[s.top()] = 0, s.pop();
                    sz[sc]++;
                }
            };
            sz.resize(1);
            scc.clear(), scc.resize(n + 1);
            for (int i = 1; i <= n; i++)
            {
                if(i == find(find, i))
                    tarjan(tarjan, i);
            }
            auto rebuild = [&]() ->void
            {
                tot = sz.size() - 1;
                for (int i = 1; i <= n; i++)
                {
                    adj[i].clear();
                }
                indegree.clear(), indegree.resize(tot + 1);
                for (auto [u, v] : edges)
                {
                    u = find(find, u), v = find(find, v);
                    u = scc[u], v = scc[v];
                    adj[u].push_back(v);
                    indegree[v]++;
                }
            };
            rebuild();

            auto topSort = [&]() -> vector<int>
            {
                queue<int> q;
                for (int i = 1; i <= tot; i++)
                {
                    if(indegree[i] == 0)
                        q.push(i);
                }
                vector<int> ans;
                while (!q.empty())
                {
                    int cur = q.front();
                    q.pop();
                    ans.push_back(cur);
                    for (int to : adj[cur])
                    {
                        if(--indegree[to] == 0)
                            q.push(to);
                    }
                }
                return ans;
            };
            auto ts = topSort();
            for (int i = 1; i <= n; i++)
            {
                cango[i].reset();
            }
            for (int i = ts.size() - 1; i >= 0; i--)
            {
                int cur = ts[i];
                cango[cur][cur] = 1;
                for (int to : adj[cur])
                {
                    cango[cur] |= cango[to];
                }
            }

            nowl++;
        }
        if(nowl == 1)
            ans[id] = a == b;
        else
        {
            ans[id] = cango[scc[find(find, a)]][scc[find(find, b)]];
            // cerr << cango[1] << endl;
            // cerr << scc[find(find, a)] << " " << scc[find(find, b)] << " " << cango[scc[find(find, a)]][scc[find(find, b)]] << endl;
        }
    }
    for (auto x : ans)
    {
        cout << x;
    }
    cout << '\n';
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        solve();
    }
    
}