/*
 
_/      _/    _/      _/    _/      _/   _/_/_/_/_/     _/_/       _/      _/ 
 _/    _/     _/      _/     _/    _/        _/       _/    _/     _/      _/            
  _/  _/      _/      _/      _/  _/         _/      _/      _/    _/_/  _/_/         
   _/_/       _/_/_/_/_/        _/           _/      _/      _/    _/  _/  _/          
  _/  _/      _/      _/        _/           _/      _/      _/    _/      _/          
 _/    _/     _/      _/        _/           _/       _/    _/     _/      _/          
_/      _/    _/      _/        _/           _/         _/_/       _/      _/       
 
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
using i64 = long long;
#define rep(i,a,n) for(int i=a;i<n;i++)
#define per(i,a,n) for(int i=n-1;i>=a;i--)
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define multi int _;cin>>_;while(_--)
#define debug(x) cerr << #x << " = " << (x) << endl;
#define int long long
#define pb push_back
#define eb emplace_back
ll gcd(ll a,ll b){ return b?gcd(b,a%b):a;}
mt19937_64 mrand(chrono::steady_clock().now().time_since_epoch().count());
int rnd(int l,int r){ return mrand() % (r - l + 1) + l;}
void test() {cerr << "\n";}
template<typename T, typename... Args> 
void test(T x, Args... args) {cerr << x << " ";test(args...);}
const ll MOD = 998244353;
// const ll MOD = 1e9+7;
ll ksm(ll x,ll y){ll ans=1;x%=MOD;while(y){if(y&1)ans=ans*x%MOD;x=x*x%MOD,y/=2;}return ans;}

const int P1 = 972152273, base1 = 809;
const int P2 = 905563261, base2 = 919;
const ll N = 200005;
//head

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

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

struct SCC {
    int n;
    std::vector<std::vector<int>> adj;
    std::vector<int> stk;
    std::vector<int> dfn, low, bel;
    int cur, cnt;
    
    SCC() {}
    SCC(int n) {
        init(n);
    }
    
    void init(int n) {
        this->n = n;
        adj.assign(n + 1, {});
        dfn.assign(n + 1, -1);
        low.resize(n + 1);
        bel.assign(n + 1, -1);
        stk.clear();
        cur = cnt = 0;
    }
    
    void addEdge(int u, int v) {
        adj[u].push_back(v);
    }
    
    void dfs(int x) {
        dfn[x] = low[x] = cur++;
        stk.push_back(x);
        
        for (auto y : adj[x]) {
            if (dfn[y] == -1) {
                dfs(y);
                low[x] = std::min(low[x], low[y]);
            } else if (bel[y] == -1) {
                low[x] = std::min(low[x], dfn[y]);
            }
        }
        
        if (dfn[x] == low[x]) {
            int y;
            ++cnt;
            do {
                y = stk.back();
                bel[y] = cnt;
                stk.pop_back();
            } while (y != x);
        }
    }
    
    std::vector<int> work() {
        for (int i = 1; i <= n; i++) {
            if (dfn[i] == -1) {
                dfs(i);
            }
        }
        return bel;
    }
};


void solve(int testcase) {
	int n, l, q;
	std::cin >> n >> l >> q;
	std::vector t(l + 1, std::vector<int> (n + 1));
	for (int i = 1; i <= l; i++) {
		std::string s;
		std::cin >> s;
		for (int j = 0; j < n; j++) {
			t[i][j + 1] = decode(s[j * 2], s[j * 2 + 1]);
			// std::cout << t[i][j + 1] << " \n"[j == n - 1];
		}
	}
	
	std::vector<std::array<int, 4>> query(q);
	for (int i = 0; i < q; i++) {
		std::string s;
		std::cin >> s;
		int u = decode(s[0], s[1]);
		int v = decode(s[2], s[3]);
		int c = decode(s[4], s[5]);
		query[i] = {u, v, c, i};
	}
	
	std::sort(query.begin(), query.end(), [&](auto a, auto b) {
		return a[2] < b[2];
	});
	
	int j = 0;
	
	std::vector<std::pair<int, int>> edges;
	DSU dsu(n + 1);
	std::vector<int> bel(n + 1);
	std::vector<std::bitset<2005>> f(n + 1);
	for (int i = 1; i <= n; i++) {
		bel[i] = i;
		f[i][i] = 1;
	}
	
	auto build = [&]() {
		f.assign(n + 1, {});
		SCC scc(n);
		for (auto [x, y] : edges) {
			scc.addEdge(dsu.leader(x), dsu.leader(y));
		}
		bel = scc.work();
		for (int i = 1; i <= n; i++) {
			f[bel[dsu.leader(i)]][bel[dsu.leader(i)]] = 1;
		}
		
		std::vector<std::vector<int>> adj(n + 1);
		std::vector<int> d(n + 1);
		for (auto [x, y] : edges) {
			if (bel[dsu.leader(x)] != bel[dsu.leader(y)]) {
				adj[bel[dsu.leader(x)]].push_back(bel[dsu.leader(y)]);
				d[bel[dsu.leader(y)]]++;
			}
		}
		
		std::queue<int> q;
		for (int i = 1; i <= n; i++) {
			if (d[i] == 0) {
				q.push(i);
			}
		}
		
		while (!q.empty()) {
			int x = q.front();
			q.pop();
			for (auto y : adj[x]) {
				f[y] |= f[x];
				if (--d[y] == 0) {
					q.push(y);
				}
			}
		}
		// for (int i = 1; i <= n; i++) {
			// std::cerr << bel[dsu.leader(i)] << " \n"[i == n];
		// }
		// for (int i = 1; i <= n; i++) {
			// for (int j = 1; j <= n; j++) {
				// std::cerr << f[i][j] << " \n"[j == n];
			// }
		// }
		// std::cerr << std::endl;
	};
	
	auto work = [&](int id) {
		auto &v = t[id];
		std::vector<int> ind(n + 1);
		for (int i = 1; i <= n; i++) {
			ind[v[i]]++;
		}
		
		int cnt = 0;
		for (int i = 1; i <= n; i++) {
			if (ind[i] == 0) {
				cnt++;
			}
		}
		
		if (cnt == 0) {
			std::vector<int> vis(n + 1);
			for (int i = 1; i <= n; i++) {
				if (vis[i] == 0) {
					int x = i;
					while (vis[v[x]] != 1) {
						dsu.merge(x, v[x]);
						x = v[x];
						vis[x] = 1;
					}
				}
			}
			build();
		} else if (cnt == 1) {
			int p = 0;
			int x = 0;
			for (int i = 1; i <= n; i++) {
				if (ind[i] == 2) {
					p = i;
					break;
				}
			}
			for (int i = 1; i <= n; i++) {
				if (ind[i] == 0) {
					x = i;
					break;
				}
			}

			for (int i = 1; i <= n; i++) {
				if (v[i] == p) {
					if (i != x) edges.push_back({i, x});
				}
			}
			
			build();
		
		} else {
			return;
		}
	};
	
	
	std::vector<int> ans(q);
	for (auto [s, t, c, id] : query) {
		while (j < c) {
			j++;
			work(j);
		}
		if (bel[dsu.leader(t)] == bel[dsu.leader(s)]) {
			ans[id] = 1;
		} else {
			ans[id] = f[bel[dsu.leader(t)]][bel[dsu.leader(s)]];
		}
	}
	
	for (int i = 0; i < q; i++) {
		std::cout << ans[i];
	}
	std::cout << "\n";
	
}

signed main()
{  
#ifdef localfreopen
    // freopen("1.in","r",stdin);
#endif
    fastio
    std::cout << std::fixed << std::setprecision(10);
    int t;
    cin >> t;
    for(int i = 1 ; i <= t ; i++ )
    {
        solve(i);
    }
    return 0;
}