#include <bits/stdc++.h>
const int N = 2048;

void charming() {
  int n, l, q; std::cin >> n >> l >> q;
  std::vector move(l, std::vector<int> (n));

  std::function<int(std::string)> decoder = [&](std::string s) {
    int x = s[0] - '0', y = s[1] - '0';
    return x * 50 + y;
  };

  for (int i = 0; i < l; ++i) {
    std::string s; std::cin >> s;
    for (int j = 0; j < s.size(); j += 2) {
      int x = decoder(s.substr(j, 2));
      move[i][j / 2] = x, --move[i][j / 2];
    }
  }

  std::vector<int> ans(q);
  std::vector qry(l + 1, std::vector<std::array<int, 3> > ());
  for (int i = 0, a, b, c; i < q; ++i) {
    std::string word; std::cin >> word;
    a = decoder(word.substr(0, 2)) - 1;
    b = decoder(word.substr(2, 2)) - 1;
    c = decoder(word.substr(4, 2)) - 1;
    if (a == b) ans[i] = 1;
    else if (c >= 0) qry[c].emplace_back((std::array<int, 3>) {a, b, i});
  }

  std::vector<int> pre(n);
  std::iota(pre.begin(), pre.end(), 0);
  std::vector G(n, std::vector<int> ());

  std::function<int(int)> find = [&](int x) {
    if (x == pre[x]) return x;
    else return pre[x] = find(pre[x]);
  };

  std::vector<int> used(n);
  std::function<void(int, int&, std::vector<int>&, std::vector<int>&, std::vector<int>&, std::vector<int>&)> DFS = 
  [&](int u, int &tot, std::vector<int> &dfn, std::vector<int> &low, std::vector<int> &stk, std::vector<int> &pre) {
    dfn[u] = low[u] = ++tot;
    stk.emplace_back(u);
    for (int v : G[u]) {
      if (!dfn[v]) {
        DFS(v, tot, dfn, low, stk, pre);
        low[u] = std::min(low[u], low[v]);
      }
      else if (!used[v]) low[u] = std::min(low[u], dfn[v]);
    }
    // std::cout << "tarjan - " << u << ' ' << dfn[u] << ' ' << low[u] << '\n';
    if (low[u] >= dfn[u]) {
      // std::cout << "Scc: " << u << '\n';
      // for (auto x : stk) std::cout << x << ' ';
      // std::cout << '\n';
      while (stk.back() != u) {
        assert(!stk.empty());
        pre[stk.back()] = u, used[stk.back()] = 1;
        stk.pop_back();
      }
      pre[u] = u, used[u] = 1;
      stk.pop_back();
    }
  };

  std::function<std::vector<int>(std::vector<int>&)> Tarjan = [&](std::vector<int> &pre) {
    // std::cout << "Before tarjan.\n";
    // for (int u = 0; u < n; ++u) std::cout << find(u) << " \n"[u == n - 1];
    // for (int u = 0; u < n; ++u) {
    //   for (int v : G[u]) std::cout << u << ' ' << v << '\n';
    // }

    std::vector<int> new_pre = pre;
    std::vector<int> dfn(n), low(n);
    used = std::vector<int> (n);
    int tot = 0;
    for (int i = 0; i < n; ++i) if (!dfn[i] && i == find(i)) {
      std::vector<int> stk;
      
      DFS(i, tot, dfn, low, stk, new_pre);
    }
    return new_pre;
  };

	std::function<std::vector<std::vector<int> > ()> Shrink = [&]() {
    std::vector nG(n, std::vector<int> ());
    for (int u = 0, fu, fv; u < n; ++u) {
      fu = find(u);
      for (int v : G[u]) {
        fv = find(v);
        if (fu != fv) nG[fu].emplace_back(fv);
      }
    }
    return nG;
  };

  std::function<void(std::vector<int>&, std::vector<std::array<int, 3> >&)> Solve 
  = [&](std::vector<int> &ans, std::vector<std::array<int, 3> > &qry) {
    if (!qry.size()) return;
    std::vector<std::bitset<N> > f(n);
    std::vector<int> du(n);
    std::vector revG(n, std::vector<int>());
    for (int u = 0; u < n; ++u) if (u == find(u)) {
      f[u][u] = 1;
      for (int v : G[u]) {
        ++du[u], revG[v].emplace_back(u);
        // std::cout << u << ' ' << v << '\n';
      }
    }
    std::vector<int> q;
    int head = 0, tail = 0;
    for (int u = 0; u < n; ++u) if (u == find(u) && !du[u]) {
      q.emplace_back(u), ++tail;
    }
    while (head < tail) {
      int u = q[head++];
      // std::cout << u << '\n';
      for (int v : revG[u]) {
        --du[v];
        f[v] |= f[u];
        if (!du[v]) q.emplace_back(v), ++tail;
      }
    }

    for (auto [u, v, q_idx] : qry) {
      int fu = find(u), fv = find(v);
      // std::cout << "? " << ans[q_idx] << ' ' << fu << ' ' << fv << '\n';
      // for (int i = 0; i < n; ++i) std::cout << f[fu].test(i);
      // std::cout << '\n' << fu << ' ' << fv << ' ' << f[fu].test(fv) << ' ' << f[fu][fv];
      // std::cout << '\n';
      if (f[fu].test(fv)) ans[q_idx] = 1;
      else ans[q_idx] = 0;
    }

    // std::cout << "Check\n";
    // for (int u = 0; u < n; ++u) {
    //   for (int v : G[u]) {
    //     std::cout << u << ' ' << v << '\n';
    //   }
    // // }
    // for (int u = 0; u < n; ++u) if (u == find(u)) {
    //   std::cout << u << ": ";
    //   for (int v = 0; v < n; ++v) std::cout << f[u][v];
    //   std::cout << '\n';
    // }
  };

  for (int i = 0; i < l; ++i) {
    std::vector<int> vis(n);
    std::unordered_set<int> s;
    for (int j = 1; j < n; ++j) assert(move[i][j] < n), ++vis[move[i][j]];
    for (int j = 0; j < n; ++j) if (!vis[j]) s.insert(j);
    for (int u = 0, fu, fv; u < n; ++u) {
      fu = find(u);
      if (int(s.size()) == 1) {
        int v = *s.begin();
        fv = find(v);
        if (fu != fv) {
          G[fu].emplace_back(fv);
          // std::cout << "Add edge " << u << ' ' << v << '\n';
        }
      }
      int nxt0 = move[i][u];
      ++vis[nxt0];
      if (vis[nxt0] == 1) assert(s.count(nxt0)), s.erase(nxt0);
      if (u < n - 1) {
        int nxt1 = move[i][u + 1];
        --vis[nxt1];
        if (!vis[nxt1]) s.insert(nxt1);
      }
    }

    pre = Tarjan(pre);
    // std::cout << "Before Shrink\n";
    // for (int u = 0; u < n; ++u) std::cout << find(u) << " \n"[u == n - 1];
    G = Shrink();
    // std::cout << "After Shrink \n";
    // for (int u = 0; u < n; ++u) {
    //   std::cout << u << ' ' << find(u) << '\n';
    //   if (u == find(u)) {
    //     for (int v : G[u]) {
    //       std::cout << "- " << u << ' ' << v << '\n';
    //     }
    //   }
    // }

    Solve(ans, qry[i]);
  }

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

signed main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(NULL);
  std::cout.tie(NULL);
  int t; std::cin >> t;
  while (t--) charming();
  return 0;
}