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

#define IOS ios::sync_with_stdio(0), cin.tie(0)
#define int long long
#define endl '\n'
#define lowbit(x) (x)&(-x)
#define all(s) s.begin(), s.end()
#define pii pair<int, int>
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)
#define here system("pause")

template <class T>
inline void read(T &x) {
    x = 0;
    char c = getchar();
    bool f = 0;
    for (; !isdigit(c); c = getchar()) f ^= (c == '-');
    for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
    x = f ? -x : x;
}

template <class T>
inline void write(T x) {
    if (x < 0) putchar('-'), x = -x;
    if (x < 10) putchar(x + 48);
    else write(x / 10), putchar(x % 10 + 48);
}

template<typename T> void chkmin(T& lhs, const T& rhs) { lhs = lhs > rhs ? rhs : lhs; }
template<typename T> void chkmax(T& lhs, const T& rhs) { lhs = lhs < rhs ? rhs : lhs; }

const int N = 2e5 + 5;
const int mod = 998244353;
const int INF = 8e17 + 9;
const double eps = 1e-9;
const double Pi = acos(-1);

inline int pow(int a, int b, int p) {
    int res = 1 % p;
    while (b) {
        if (b & 1) res = res * a % p;
        a = a * a % p, b >>= 1;
    }
    return res;
}

inline int inv(int a, int p) {
    return pow(a, p - 2, p) % p;
}

mt19937_64 rnd(chrono::duration_cast<chrono::nanoseconds>(chrono::system_clock::now().time_since_epoch()).count());
int randint(int L, int R) {
    uniform_int_distribution<int> dist(L, R);
    return dist(rnd);
}

int n, l, q;

using ull = unsigned long long;
struct Bitset {
    static constexpr int BITS = (2005 >> 6) + 5;
    ull bit[BITS];
    int len = BITS;

    inline void reset() { memset(bit, 0, sizeof(bit)); }
    Bitset() { reset(); }

    inline void set(int x) {
        if (x >= 0 && x < 2005) bit[x >> 6] |= 1ULL << (x & 63);
    }

    inline void set0(int x) {
        if (x >= 0 && x < 2005) bit[x >> 6] &= ~(1ULL << (x & 63));
    }

    inline void flip(int x) {
        if (x >= 0 && x < 2005) bit[x >> 6] ^= 1ULL << (x & 63);
    }

    bool operator[](int x) const {
        return (x >= 0 && x < 2005) && ((bit[x >> 6] >> (x & 63)) & 1);
    }

    Bitset operator~(void) const {
        Bitset res;
        for (int i = 0; i < len; i++) res.bit[i] = ~bit[i];
        return res;
    }

    Bitset operator&(const Bitset &b) const {
        Bitset res;
        for (int i = 0; i < len; i++) res.bit[i] = bit[i] & b.bit[i];
        return res;
    }

    Bitset operator|(const Bitset &b) const {
        Bitset res;
        for (int i = 0; i < len; i++) res.bit[i] = bit[i] | b.bit[i];
        return res;
    }

    Bitset operator^(const Bitset &b) const {
        Bitset res;
        for (int i = 0; i < len; i++) res.bit[i] = bit[i] ^ b.bit[i];
        return res;
    }

    void operator&=(const Bitset &b) {
        for (int i = 0; i < len; i++) bit[i] &= b.bit[i];
    }

    void operator|=(const Bitset &b) {
        for (int i = 0; i < len; i++) bit[i] |= b.bit[i];
    }

    void operator^=(const Bitset &b) {
        for (int i = 0; i < len; i++) bit[i] ^= b.bit[i];
    }

    Bitset operator<<(const int t) const {
        Bitset res; int high = t >> 6, low = t & 63;
        ull last = 0;
        for (int i = 0; i + high < len; i++) {
            res.bit[i + high] = (last | (bit[i] << low));
            if (low) last = (bit[i] >> (64 - low));
        }
        return res;
    }

    Bitset operator>>(const int t) const {
        Bitset res; int high = t >> 6, low = t & 63;
        ull last = 0;
        for (int i = len - 1; i >= high; i--) {
            res.bit[i - high] = last | (bit[i] >> low);
            if (low) last = bit[i] << (64 - low);
        }
        return res;
    }

    void operator<<=(const int t) {
        int high = t >> 6, low = t & 63;
        for (int i = len - high - 1; i >= 0; i--) {
            bit[i + high] = (bit[i] << low);
            if (low && i) bit[i + high] |= bit[i - 1] >> (64 - low);
        }
        for (int i = 0; i < high; i++) bit[i] = 0;
    }
} b[2005];

inline void merge(int u, int v) {
    if (b[u][v]) return;
    for (int i = 1; i <= n; i++) {
        if (b[i][u]) b[i] |= b[v];
    }
}

inline void work(vector<int> &A) {
    vector<int> vis(n + 1);
    int last = 0;
    for (int i = 1; i <= n; i++) {
        if (!vis[A[i]]) {
            vis[A[i]] = 1;
        } else if (!last) {
            last = A[i];
        } else {
            return;
        }
    }
    if (!last) {
        for (int i = 1; i <= n; i++) {
            merge(i, A[i]);
        }
    } else {
        int tmp = 0;
        for (int i = 1; i <= n; i++) {
            if (!vis[i]) {
                tmp = i;
            }
        }
        for (int i = 1; i <= n; i++) {
            if (A[i] == last) {
                merge(i, tmp);
            }
        }
    }
}

inline void sol() {
    cin >> n >> l >> q;
    for (int i = 1; i <= n; i++) {
        b[i].reset();
        b[i].set(i);
    }
    vector<vector<int>> G(l + 1, vector<int>(n + 1));
    vector<vector<array<int, 3>>> qry(l + 1);
    vector<int> ans(q + 1);

    auto decode = [&]() {
        char a, b;
        cin >> a >> b;
        return (a - '0') * 50 + (b - '0');
    };

    for (int i = 1; i <= l; i++) {
        for (int j = 1; j <= n; j++) {
            G[i][j] = decode();
        }
    }

    for (int i = 1; i <= q; i++) {
        int x = decode(), y = decode(), id = decode();
        qry[id].push_back({i, x, y});
    }

    for (int i = 0; i <= l; i++) {
        work(G[i]);
        for (auto t : qry[i]) {
            ans[t[0]] = b[t[1]][t[2]];
        }
    }

    for (int i = 1; i <= q; i++) {
        cout << ans[i];
    }
    cout << endl;
}

signed main() {
    IOS;
    int tc = 1;
    cin >> tc;
    while (tc--) {
        sol();
    }
    return 0;
}