#include <bits/stdc++.h>

using namespace std;


const int mod = 998244353;
bitset<2005> dp[2005];


template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "{";
    for (const T &x: v) {
        os << x << " ";
    }
    os << "}";
    return os;
}


using i64 = long long;


class Tarjan {
    int n;
    vector<vector<int>> G;
    vector<vector<int>> rG;
    vector<vector<int>> go;
    vector<int> scc;
    vector<int> dfn, up, du;
public:

    Tarjan(int _n) : n(_n), G(n + 1), scc(n + 1) {
        iota(scc.begin(), scc.end(), 0);
    }

    void init() {
        int _n = n;
        // tarjan 更新 scc ys n
        {
            vector<int> _dfn(n + 1), _low(n + 1);
            vector<int> _scc(n + 1);
            vector<int> _ys(n + 1);
            vector<int> _stk(n + 1);
            int _top = 0;
            int _scc_cnt = 1;
            int _dfn_cnt = 0;
            function<void(int)> tarjan = [&](int u) {
                _dfn[u] = _low[u] = ++_dfn_cnt;
                _stk[++_top] = u;
                for (int v: G[u]) {
                    if (!_dfn[v]) {
                        tarjan(v);
                        _low[u] = min(_low[u], _low[v]);
                    } else if (!_scc[v]) {
                        _low[u] = min(_low[u], _dfn[v]);
                    }
                }
                if (_dfn[u] == _low[u]) {
                    int v;
                    do {
                        v = _stk[_top--];
                        _scc[v] = _scc_cnt;
                    } while (v != u);
                    _scc_cnt++;
                }
            };
            for (int i = 1; i <= _n; i++) {
                if (!_dfn[i]) {
                    tarjan(i);
                }
            }
            int nn = scc.size() - 1;
            for (int i = 1; i <= nn; i++) {
                scc[i] = _scc[scc[i]];
            }
            n = _scc_cnt - 1;
            // 更新图
            {
                vector<vector<int>> _G(n + 1);
                vector<vector<int>> _rG(n + 1);
                vector<int> _du(n + 1);
                for (int i = 1; i <= _n; i++) {
                    for (int j: G[i]) {
                        if (_scc[i] != _scc[j]) {
                            _G[_scc[i]].push_back(_scc[j]);
                            _rG[_scc[j]].push_back(_scc[i]);
                            _du[_scc[i]]++;
                        }
                    }
                }
                G = _G;
                rG = _rG;
                du = _du;
            }
        }
        {

            for (int i = 1; i <= n; i++) {
                dp[i].reset();
            }
            stack<int> stk;
            for (int i = 1; i <= n; i++) {
                dp[i][i] = true;
                if (du[i] == 0) {
                    stk.push(i);
                }
            }
            while (!stk.empty()) {
                int u = stk.top();
                stk.pop();
                for (int v: rG[u]) {
                    dp[v] |= dp[u];
                    du[v]--;
                    if (du[v] == 0) {
                        stk.push(v);
                    }
                }
            }

        }

    }

    bool can_reach(int u, int v) {
        u = scc[u];
        v = scc[v];
        return dp[u][v];
   
    }
//    }

    bool add_edge(int u, int v) {
        if (scc[u] != scc[v]) {
//            cerr << "add edge " << u << " " << v << endl;
            G[scc[u]].push_back(scc[v]);
            rG[scc[v]].push_back(scc[u]);
            return true;
        }
        return false;
    }
};

int decreace(char a, char b) {
    return (a - 48) * 50 + (b - 48);
}

class Query {
public:
    int from, to, time, idx;

    Query(int from, int to, int time, int idx) : from(from), to(to), time(time), idx(idx) {}

    bool operator<(const Query &q) const {
        return time < q.time;
    }

};

// 解密字符串
vector<int> decrypt(const string &s) {
    vector<int> res = {0};
    for (int i = 0; i < s.size(); i += 2) {
        res.push_back(decreace(s[i], s[i + 1]));
    }
    return res;
}


void solve() {
    int n, l, q;
    cin >> n >> l >> q;
    vector<string> s(l + 1);
    for (int i = 1; i <= l; i++) {
        cin >> s[i];
    }
    vector<Query> qs;
    for (int i = 0; i < q; i++) {
        string sa;
        cin >> sa;
        auto v = decrypt(sa);
        qs.emplace_back(v[1], v[2], v[3], i);
    }
    sort(qs.begin(), qs.end());
    int now = 0;
    vector<int> ans(q);
    Tarjan tarjan(n);
    auto modify = [&](int _i) -> bool {
        bool f = false;
        auto v = decrypt(s[_i]);
//        cerr << v << endl;
        vector<int> du(n + 1);
        for (int i = 1; i <= n; i++) {
            du[v[i]]++;
        }
        //找到入度为0的个数
        int cnt = 0;
        int cnt_id;
        for (int i = 1; i <= n; i++) {
            if (du[i] == 0) {
                cnt++;
                cnt_id = i;
            }
        }
        if (cnt == 0) {
            for (int i = 1; i <= n; i++) {
//                cerr << i << " " << v[i] << endl;
                f |= tarjan.add_edge(i, v[i]);
            }
//            return true;
        } else if (cnt == 1) {
            int i = cnt_id;
            while (du[i] == 0) {
                if (du[v[i]] == 2) {
                    f |= tarjan.add_edge(i, cnt_id);
                }
                i = v[i];
                du[i]--;

            }
            int j = v[i];
            while (v[j] != i) {
                f |= tarjan.add_edge(j, v[j]);
            }
            f |= tarjan.add_edge(j, cnt_id);
        }
        return f;
    };
    tarjan.init();
    for (auto &qq: qs) {
        bool f = false;
        while (now < qq.time) {
            now++;
            f |= modify(now);
        }
        if (f) {
            tarjan.init();
        }
        ans[qq.idx] = tarjan.can_reach(qq.from, qq.to);
//        cerr << qq.idx << " " << qq.from << " " << qq.to << " " << qq.time << " " << ans[qq.idx] << endl;
    }
    for (int i = 0; i < q; i++) {
        cout << ans[i];
    }
    cout << endl;

}

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