#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <array>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <bitset>
using namespace std;
using ll = long long;


struct DSU {
	vector<int> p, siz;

	DSU() {}
	DSU(int n) {
		init(n);
	}

	void init(int n) {
		p.resize(n + 1);
		iota(p.begin(), p.end(), 0);
		siz.assign(n + 1, 1);
	}

	int find(int x) {
		while (x != p[x]) x = p[x] = p[p[x]];
		return x;
	}

	bool same(int x, int y) {
		return find(x) == find(y);
	}

	bool uno(int x, int y) {
		x = find(x), y = find(y);
		if (same(x, y)) return 0;
		siz[x] += siz[y];
		p[y] = x;
		return 1;
	}

	int size(int x) {
		return siz[find(x)];
	}
};

int read() {
	char u, v;
	cin >> u >> v;
	return (u - 48) * 50 + v - 48;
}

const int N = 2008;

void eachT() {
	int n, l, q;
	cin >> n >> l >> q;

	vector<vector<pair<int, int>>> E(l + 1);
	for (int i = 1; i <= l; ++i) {
		unordered_map<int, int> cnt;
		vector<int> t(n + 1);
		for (int j = 1; j <= n; ++j) {
			t[j] = read();
			cnt[t[j]] += 1;
		}
		int mul = -1, zero = -1, ok = 1;
		for (int j = 1; j <= n; ++j) {
			if (cnt[j] == 2) {
				if (mul == -1) mul = j;
				else ok = 0;
			}
			if (cnt[j] == 0) {
				if (zero == -1) zero = j;
				else ok = 0;
			}
		}
		if (!ok) continue;
		if (mul == -1) {
			for (int j = 1; j <= n; ++j) {
				E[i].emplace_back(j, t[j]);
			}
		}
		else for (int j = 1; j <= n; ++j) {
			if (cnt[t[j]] == 2) {
				E[i].emplace_back(j, zero);
			}
		}
	}

	vector<vector<tuple<int, int, int>>> que(l + 1);
	for (int i = 0; i < q; ++i) {
		int a = read(), b = read(), c = read();
		que[c].emplace_back(a, b, i);
	}

	vector<int> ans(q);
	vector<vector<int>> adj(n + 1);
	DSU dsu(n);
	for (int c = 0; c <= l; ++c) {
		for (auto& [u, v] : E[c]) {
			adj[dsu.find(v)].push_back(dsu.find(u));
		}

		// Tarjan
		vector<int> dfn(n + 1), low(n + 1), fa(n + 1);
		int unix = 0;
		stack<int> stk;
		auto dfs = [&](auto&& self, int u) -> void {
			dfn[u] = low[u] = ++unix;
			stk.push(u);
			for (auto& v : adj[u]) {
				if (!dfn[v]) self(self, v), low[u] = min(low[u], low[v]);
				else if (!fa[v]) low[u] = min(low[u], dfn[v]);
			}
			if (low[u] == dfn[u]) {
				int v;
				do {
					v = stk.top(); stk.pop();
					fa[v] = u;
				} while (v != u);
			}
		};
		for (int u = 1; u <= n; ++u) {
			if (!dfn[u]) dfs(dfs, u);
		}

		vector<vector<int>> tadj(n + 1);
		for (int u = 1; u <= n; ++u) {
			for (auto& v : adj[u]) {
				if (fa[u] != fa[v]) tadj[fa[u]].push_back(fa[v]);
			}
		}
		for (int u = 1; u <= n; ++u) {
			dsu.uno(fa[u], u);
			adj[u] = tadj[u];
			adj[u].erase(unique(adj[u].begin(), adj[u].end()), adj[u].end());
		}

		vector<int> deg(n + 1);
		vector<bitset<N>> dp(n + 1);
		for (int u = 1; u <= n; ++u) {
			for (auto v : adj[u]) {
				deg[v] += 1;
			}
		}
		queue<int> Q;
		for (int u = 1; u <= n; ++u) {
			dp[u][u] = u;
			if (!deg[u]) Q.push(u);
		}
		while (!Q.empty()) {
			int u = Q.front(); Q.pop();
			for (auto to : adj[u]) {
				deg[to] -= 1;
				dp[to] |= dp[u];
				if (!deg[to]) Q.push(to);
			}
		}

		for (auto& [a, b, id] : que[c]) {
			if (dp[dsu.find(a)][dsu.find(b)] == 1) ans[id] = 1;
		}
	}

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

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

	int T = 1;
	cin >> T;

	while (T--) {
		eachT();
	}

	return 0;
}