#include <bits/stdc++.h>
using namespace std;

// We'll keep "int" as 64-bit:
using ll = long long;
#define int long long

#define all(x) (x).begin(), (x).end()
#define put(x) cout << (x) << "\n"

// Kosaraju's algorithm for SCC
void dfs1(int node, const vector<vector<int>>& adj, vector<bool>& visited, stack<int>& st) {
    visited[node] = true;
    for (int nx : adj[node]) {
        if (!visited[nx]) dfs1(nx, adj, visited, st);
    }
    st.push(node);
}
void dfs2(int node, const vector<vector<int>>& radj, vector<bool>& visited, vector<int>& comp) {
    visited[node] = true;
    comp.push_back(node);
    for (int nx : radj[node]) {
        if (!visited[nx]) dfs2(nx, radj, visited, comp);
    }
}
vector<int> buildSCC(int n, const vector<vector<int>>& edges) {
    // 1) build adjacency
    vector<vector<int>> adj(n), radj(n);
    for (auto &e : edges) {
        adj[e[0]].push_back(e[1]);
        radj[e[1]].push_back(e[0]);
    }

    // 2) DFS for finishing order
    stack<int> st;
    vector<bool> visited(n,false);
    for(int i=0; i<n; i++){
        if(!visited[i]) dfs1(i, adj, visited, st);
    }

    // 3) DFS on reversed in order
    fill(visited.begin(), visited.end(), false);
    vector<int> compID(n, 0);
    int cIndex = 0;
    while(!st.empty()){
        int node = st.top(); st.pop();
        if(!visited[node]) {
            cIndex++;
            vector<int> comp;
            dfs2(node, radj, visited, comp);
            for (auto v : comp) {
                compID[v] = cIndex;
            }
        }
    }
    return compID; // compID[v] is 1-based index of which SCC v belongs to
}

// Utility: sum of pairs in an interval of length L
inline ll pairs_in_interval(ll L) {
    if (L <= 1) return 0;
    return (L * (L - 1)) / 2;
}

// Get compID-segments in a contiguous slice of the list array
// listArr = your list of nodes (size n), compID[node] = scc
// We'll iterate from start..end (mod n if needed) and sum pairs
ll countPairsInSubarray(const vector<int>& listArr,
                        const vector<int>& compID,
                        int n, int start, int end, bool wrap) {
    // If not wrap and start <= end, we just do a straightforward pass [start..end].
    // If wrap is true, we do [start..n-1], then [0..end].
    // We'll split whenever compID changes.

    ll ans = 0;
    // We'll keep a running length of the current compID block
    ll blockLen = 1;
    int currentComp = compID[ listArr[start] ];

    auto advance = [&](int &i) {
        i = (i + 1) % n; // wrap around
    };

    // The total number of elements in the sub-array
    int totalLen;
    if (!wrap) {
        totalLen = (end - start + 1);
    } else {
        // e.g. if start=2, end=1, n=5 => sub-array length= (5-2) + (1+1)= 4 => actually 5?
        // Actually (end - start + n) % n + 1 is a robust formula
        totalLen = ((end - start) % n + n) % n + 1;
    }

    int idx = start;
    for (int step = 1; step < totalLen; step++) {
        // Move idx forward
        int nxt = (idx + 1) % n;
        // If we're in non-wrap mode but idx == end, we should stop.
        // But we rely on 'step < totalLen' anyway.
        idx = nxt;
        int c = compID[ listArr[idx] ];
        if (c == currentComp) {
            blockLen++;
        } else {
            ans += pairs_in_interval(blockLen);
            blockLen = 1;
            currentComp = c;
        }
    }
    // add the final block
    ans += pairs_in_interval(blockLen);
    return ans;
}

void solve() {
    int n, k, q;
    cin >> n >> k >> q;

    // Build edges from k lists
    vector<vector<int>> lists(k, vector<int>(n));
    vector<vector<int>> edges;
    edges.reserve(k * (n - 1));

    // Read permutations
    for(int i=0; i<k; i++){
        for(int j=0; j<n; j++){
            cin >> lists[i][j];
            lists[i][j]--;  // zero-based
            if(j>0){
                edges.push_back({lists[i][j-1], lists[i][j]});
            }
        }
    }

    // Build compID via Kosaraju
    vector<int> compID = buildSCC(n, edges);
    // compID[v] is 1-based scc index

    ll prev = 0;
    while(q--){
        ll id, l, r;
        cin >> id >> l >> r;

        // Decode
        id = (id + prev) % k;
        l  = (l  + prev) % n;
        r  = (r  + prev) % n;

        // If same comp => (cyclic interpretation) from sample #1
        // but that sample only used "full cycle" if l>r. So let's replicate the logic:
        bool sameComp = (compID[ lists[id][l] ] == compID[ lists[id][r] ]);

        ll ans = 0;
        if (sameComp && (r < l)) {
            // If the endpoints are in the same comp and r<l, the sample #1 (query2) gave us a full cycle.
            // e.g. length = n => pairs = n*(n-1)/2
            // Because in test #1, everything was one big SCC, so from l=2..r=1 ended up using all 5 elements.
            ans = pairs_in_interval(n);
        } else {
            // We do a standard "sub-array" approach, possibly wrapping if r<l.
            // Count consecutive compID blocks in that sub-array.
            bool wrap = (r < l);
            ans = countPairsInSubarray(lists[id], compID, n, l, r, wrap);
        }

        cout << ans << "\n";
        prev = ans;
    }
}

int32_t main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T; cin >> T;
    while(T--){
        solve();
    }
    return 0;
}