#include <iostream>
#include <fstream>
#include <vector>
#include <array>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <bitset>
#include <set>
#include <queue>
#include <stack>
#include <random>
#include <numeric>
#include <cmath>
#include <utility>
#include <string>
#include <iomanip>
#include <functional>
#define FOR(i, s, e, t) for((i) = (s); (i) <= (e); (i) += (t))
#define ROF(i, s, e, t) for((i) = (e); (i) >= (s); (i) -= (t))
#define REP(s, e) for(long long i = (s); i <= (e); ++i)
#define PER(s, e) for(long long i = (e); i >= (s); --i)
#define ALL(x) (x).begin(), (x).end()
#define LLA(x) (x).rbegin(), (x).rend()
#define SIZE(x) ((int)(x).size())
#define AMONGlr(x, l, r) ((x) >= (l) && (x) <= (r))
#define AMONG(x, l, r) ((x) > (l) && (x) < (r))
#define AMONGl(x, l, r) ((x) >= (l) && (x) < (r))
#define AMONGr(x, l, r) ((x) > (l) && (x) <= (r))
#define pb push_back
#define qb pop_back
#define eb emplace_back
#define fi first
#define se second
#define maxe max_element
#define mine min_element
#define mp make_pair
#define upb upper_bound
#define lowb lower_bound
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef pair<string, string> pss;
typedef pair<string, ll> psl;
typedef pair<ll, string> pls;
typedef pair<string, double> psd;
typedef pair<double, string> pds;
typedef pair<ll, double> pld;
typedef pair<double, ll> pdl;
typedef pair<char, ll> pcl;
typedef pair<ll, char> plc;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pdd> vpdd;
typedef vector<pss> vpss;
typedef vector<psl> vpsl;
typedef vector<pls> vpls;
typedef vector<psd> vpsd;
typedef vector<pds> vpds;
typedef vector<pld> vpld;
typedef vector<pdl> vpdl;
typedef vector<pcl> vpcl;
typedef vector<plc> vplc;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef vector<vs> vvs;
template<typename T> bool ckMax(T& a, const T& b) { return a < b ? a = b, true : false; }
template<typename T> bool ckMin(T& a, const T& b) { return a > b ? a = b, true : false; }
inline ll read() {
	ll x = 0;
	short flag = 1;
	char c = getchar();
	while (c < '0' || c > '9') {
		if (c == '-')flag = -1;
		c = getchar();
	}
	while (c >= '0' && c <= '9') {
		x = (x << 3) + (x << 1) + (c ^ 48);
		c = getchar();
	}
	return x * flag;
}
inline void write(ll x, char end = '\0') {
	if (x < 0) {
		putchar('-');
		x = -x;
	}
	if (x > 9)
		write(x / 10);
	putchar(x % 10 + '0');
	if (end != '\0') putchar(end);
}
template<ll P>
struct MInt {
	ll x;
	inline static ll Mod = 1e9 + 7;

	constexpr MInt() : x{ 0 } {}
	constexpr MInt(ll x) : x{ norm(x % getMod()) } {}

	constexpr static ll getMod() {
		if (P > 0) return P;
		return Mod;
	}
	constexpr static MInt power(MInt a, ll b) {
		MInt res(1);
		while (b > 0) {
			if (b % 2) res *= a;
			a *= a;
			b /= 2;
		}
		return res;
	}
	constexpr static void setMod(ll Mod_) {
		Mod = Mod_;
	}
	constexpr ll norm(ll x) const {
		if (x < 0) x += getMod();
		else if (x >= getMod()) x -= getMod();
		return x;
	}
	constexpr ll val() const {
		return x;
	}
	constexpr MInt inv() const {
		return power(*this, getMod() - 2);
	}
	constexpr MInt operator-() const {
		MInt res;
		res.x = norm(getMod() - x);
		return res;
	}
	constexpr MInt& operator*=(MInt other)& {
		if (getMod() < (1ULL << 31)) x = x * other.x % int(getMod());
		else {
			x = x * other.x - ll(1.L * x * other.x / getMod()) * getMod();
			x = norm(x % getMod());
		}
		return *this;
	}
	constexpr MInt& operator+=(MInt other)& {
		x = norm(x + other.x);
		return *this;
	}
	constexpr MInt& operator-=(MInt other)& {
		x = norm(x - other.x);
		return *this;
	}
	constexpr MInt& operator/=(MInt other)& {
		return *this *= other.inv();
	}
	friend constexpr MInt operator*(MInt a, MInt b) {
		a *= b;
		return a;
	}
	friend constexpr MInt operator+(MInt a, MInt b) {
		a += b;
		return a;
	}
	friend constexpr MInt operator-(MInt a, MInt b) {
		a -= b;
		return a;
	}
	friend constexpr MInt operator/(MInt a, MInt b) {
		a /= b;
		return a;
	}
	friend constexpr istream& operator>>(istream& stream, MInt& a) {
		ll v;
		stream >> v;
		a = MInt(v);
		return stream;
	}
	friend constexpr ostream& operator<<(ostream& stream, const MInt& a) {
		return stream << a.val();
	}
	friend constexpr bool operator==(MInt a, MInt b) {
		return a.val() == b.val();
	}
	friend constexpr bool operator!=(MInt a, MInt b) {
		return a.val() != b.val();
	}
	friend constexpr bool operator<(MInt a, MInt b) {
		return a.val() < b.val();
	}
	friend constexpr bool operator>(MInt a, MInt b) {
		return a.val() > b.val();
	}
	friend constexpr bool operator<=(MInt a, MInt b) {
		return a.val() <= b.val();
	}
	friend constexpr bool operator>=(MInt a, MInt b) {
		return a.val() >= b.val();
	}
};
namespace NumberTheory {
	using T = ll;
	//必要时改成__int128

	inline ll RandInt(ll l, ll r) {
		static mt19937 rd(random_device{}());
		return uniform_int_distribution<ll>(l, r)(rd);
	}
	inline ll Mul(T a, T b, T mod) {
		T res = a * b - (T)((long double)a * b / mod + 0.5) * mod;
		return res < 0 ? res + mod : res;
	}
	inline ll Plus(ll a, ll b, ll mod) { return a + b >= mod ? a + b - mod : a + b; }
	inline ll Sub(ll a, ll b, ll mod) { return a - b < 0 ? a - b + mod : a - b; }
	T Pow(T base, T x, T mod = 0) {
		T back = 1;
		while (x > 0) {
			if (x & 1)
				if (mod) back = back * base % mod;
				else back *= base;
			if (mod) base = base * base % mod;
			else base *= base;
			x >>= 1;
		}
		if (mod) return back % mod;
		return back;
	}
	bool MillerRabin(ll n) {
		static const int TIMES = 7;
		static const int TEST[7] = { 2,3,5,7,11,13,17 };
		if (n <= 1 || n % 2 == 0 && n > 2) return false;
		else if (n <= 3) return true;

		ll t = n - 1, k = 0, i, j;
		while (!(t & 1)) t >>= 1, k += 1;
		FOR(i, 0, TIMES - 1, 1) {
			if (n == TEST[i]) return true;
			ll a = Pow(TEST[i], t, n), nxt = a;
			FOR(j, 1, k, 1) {
				nxt = Mul(a, a, n);
				if (nxt == 1 && a != 1 && a != n - 1) return false;
				a = nxt;
			}
			if (a != 1) return false;
		}
		return true;
	}
	ll PollardRho(ll n) {
		ll x, y, z, c, g, i, j;
		while (true) {
			y = x = RandInt(0, n - 1);
			z = 1;
			c = RandInt(0, n - 1);
			i = 0, j = 1;
			while (++i) {
				x = Plus(Mul(x, x, n), c, n);
				z = Mul(z, abs(x - y), n);
				if (x == y || !z) break;
				if (!(i % 127) || i == j) {
					g = gcd(z, n);
					if (g > 1) return g;
					if (i == j) y = x, i = 0, j <<= 1;
				}
			}
		}
	}
	vl GetPrimFactors(ll n) {
		vl res;
		if (n == 1) return res;
		auto dfs = [&](auto&& self, ll x) {
			if (MillerRabin(x)) return res.pb(x);
			ll y = PollardRho(x);
			self(self, x / y);
			self(self, y);
		};
		dfs(dfs, n);
		return res;
	}
	struct C {
		static const ll N = 2e5;
		const ll MOD = 1e9 + 7;
		ll mults[N], invs[N];
		void init() {
			mults[0] = 1;
			REP(1, N - 1) mults[i] = Mul(mults[i - 1], i, MOD);
			invs[N - 1] = Pow(mults[N - 1], MOD - 2, MOD);
			PER(0, N - 2) invs[i] = Mul(invs[i + 1], i + 1, MOD);
		}
		inline ll calV(ll n, ll m) {
			if (m > n || n < 0 || m < 0) return 0;
			else if (m == 0 || m == n) return 1;
			return Mul(Mul(mults[n], invs[n - m], MOD), invs[m], MOD);
		}
	};
}
int __init__ = []() {
	ios::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	return 0;
}();
const ll N = 2e3 + 10, INF = 1e16;
ll line[N], linkRect[N][N], que[N][N * 2], queHead[N], tmp[N];
ll fa[N], siz[N], tags[N], tag = 1;
vpll edges[N];
ll n, q, l, i, j;
ll find(ll x) {
	if(fa[x] == x) return x;
	return fa[x] = find(fa[x]);
}
bool concat(ll a, ll b) {
	a = find(a);
	b = find(b);
	if(a == b) return false;
	if(siz[a] < siz[b]) swap(a, b);
	siz[a] += siz[b];
	fa[b] = a;
	return true;
}
ll readLine() {
	ll i;
	string reader;
	cin >> reader;
	FOR(i, 0, SIZE(reader) - 1, 2)
		line[i / 2 + 1] = (reader[i] - 48) * 50 + reader[i + 1] - 48;
	return SIZE(reader) / 2;
}
void bfs(ll s) {
	tag += 1;
	linkRect[s][s] = 0;
	REP(0, l) queHead[i] = 0;
	que[0][++queHead[0]] = s;
	FOR(i, 0, l, 1) {
		FOR(j, 1, queHead[i], 1) {
			if(tags[que[i][j]] == tag) continue;
			tags[que[i][j]] = tag;
			for(auto& next : edges[que[i][j]]) {
				ll val = max(i, next.se);
				if(!ckMin(linkRect[s][next.fi], val)) continue;
				que[val][++queHead[val]] = next.fi;
			}
		}
	}
}
void solve() {
	cin >> n >> l >> q;
	FOR(i, 1, n, 1) {
		edges[i].clear();
		fa[i] = i;
		siz[i] = 1;
		FOR(j, 1, n, 1) linkRect[i][j] = INF;
	}
	FOR(i, 1, l, 1) {
		FOR(j, 1, n, 1) tmp[j] = -1;
		pll speLink = { -1,-1 };
		ll siz = readLine();
		FOR(j, 1, siz, 1) {
			if (tmp[line[j]] == -1) tmp[line[j]] = j;
			else if (speLink.fi != -1) {
				speLink.fi = -2;
				break;
			}
			else speLink = { tmp[line[j]],j };
		}
		if (speLink.fi == -2) continue;
		else if (speLink.fi != -1) {
			ll x = 1;
			FOR(j, 2, n, 1) if (tmp[j] == -1) {
				x = j;
				break;
			}
			edges[speLink.fi].pb({ x,i });
			edges[speLink.se].pb({ x,i });
		}
		else FOR(j, 1, siz, 1) if(concat(j, line[j])) {
            edges[j].pb({ line[j],i });
            edges[line[j]].pb({ j,i });
        }
	}
	REP(1, n) bfs(i);

	while (q--) {
		readLine();
		cout << (linkRect[line[1]][line[2]] <= line[3]);
	}
	cout << endl;
}
int main() {
	ll t = 1;
	cin >> t;
	while (t--) solve();
	return 0;
}