#include <bits/stdc++.h>
using namespace std;
void solve()
{
    int n, k, q;
    cin >> n >> k >> q;
    vector rk(k, vector<int>(n)), g(n, vector<int>());
    for (int i = 0; i < k; i++)
        for (int j = 0; j < n; j++)
        {
            cin >> rk[i][j];
            rk[i][j]--;
        }
    vector<int> scc(n), vis(n), stk, dfn(n), low(n);
    int tot = 0, scccnt = 0;
    auto tarjan = [&](auto self, int u) -> void {
        dfn[u] = low[u] = ++tot;
        stk.push_back(u);
        vis[u] = 1;
        for (auto v : g[u])
        {
            if (!dfn[v])
            {
                self(self, v);
                low[u] = min(low[u], low[v]);
            }
            else if (vis[v])
            {
                low[u] = min(low[u], dfn[v]);
            }
        }
        if (low[u] == dfn[u])
        {
            int v;
            ++scccnt;
            do
            {
                v = stk.back();
                stk.pop_back();
                vis[v] = 0;
                scc[v] = scccnt;
            } while (v != u);
        }
    };
    for (int i = 0; i < k; i++)
        for (int j = 1; j < n; j++)
            g[rk[i][j]].push_back(rk[i][j - 1]);
    for (int i = 0; i < n; i++)
        if (!dfn[i])
            tarjan(tarjan, i);

    vector Ls(k, vector<int>());
    for (int j = 0; j < k; j++)
    {
        int pre = scc[rk[j][0]];
        Ls[j].push_back(0);
        for (int i = 1; i < n; i++)
        {
            if (pre != scc[rk[j][i]])
            {
                // pref[j].push_back(( i - Ls[j].back() ) * (i - Ls[j].back() - 1) / 2);
                Ls[j].push_back(i);
                pre = scc[rk[j][i]];
            }
        }
        Ls[j].push_back(n);
    }
    const int M = Ls[0].size();
    vector pref(k, vector<int64_t>(M));
    for (int j = 0; j < k; j++)
    {
        for (int i = 1; i < M; i++)
        {
            int64_t len = Ls[j][i] - Ls[j][i - 1];
            pref[j][i] = pref[j][i - 1] + (len) * (len - 1) / 2;
        }
    }
    int64_t pre = 0;
    while (q--)
    {
        int l, r, id;
        cin >> id >> l >> r;
        id = (id + pre) % k;
        id = 0;
        tie(l, r) = minmax((l + pre) % n, (r + pre) % n);
        // cout << l << ' ' << r << '\n';
        auto L = upper_bound(Ls[id].begin(), Ls[id].end(), l) - Ls[id].begin();
        auto R = upper_bound(Ls[id].begin(), Ls[id].end(), r) - Ls[id].begin();
        if (L == R)
        {
            int64_t len = (r - l + 1);
            cout << (len) * (len - 1) / 2 << '\n';
            pre = (len) * (len - 1) / 2;
            continue;
        }
        int64_t res = pref[id][R - 1] - pref[id][L];
        int64_t lcnt = 0, rcnt = 0;
        lcnt = Ls[id][L] - l;
        rcnt = r - Ls[id][R - 1] + 1;
        res += lcnt * (lcnt - 1) / 2;
        res += rcnt * (rcnt - 1) / 2;
        cout << res << '\n';
        pre = res;
    }
}

int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    cin >> T;
    while (T--)
        solve();
    return 0;
}