#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <algorithm>
#include <iomanip>
#include <map>
#include <deque>
#include <set>
#include <random>

using namespace std;
#define ll long long
const int INF = 1e9;
vector <int> st;

void dfs(int v, vector <vector <int>>& g, vector <int>& used) {
    used[v] = 1;
    st.push_back(v);
    for (int i : g[v]) {
        if (!used[i]) dfs(i, g, used);
    }
}

void calc_dp(int v, vector <vector <int>>& g, vector <int>& dp, vector <int>& used) {
    if (used[v]) return;
    used[v] = 1;
    for (int i : g[v]) {
        calc_dp(i, g, dp, used);
        dp[v] = min(dp[v], dp[i]);
    }
}

void solve() {
    int n, k, q;
    cin >> n >> k >> q;
    vector <vector <int>> a(k, vector <int> (n));
    vector <vector <int>> pa(k, vector <int> (n));
    for (int i = 0; i < k; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> a[i][j]; --a[i][j];
            pa[i][a[i][j]] = j;
        }
    }

    vector <int> minl(n);
    for (int i = 0; i < n; ++i) {
        minl[a[0][i]] = i;
    }

    for (int i = 1; i < k; ++i) {
        vector <vector <int>> gg(n);
        for (int j = 0; j < n - 1; ++j) {
            gg[a[i - 1][j]].push_back(a[i - 1][j + 1]);
            gg[a[i][j]].push_back(a[i][j + 1]);
        }
        for (int j = 0; j < n; ++j) {
            int val = a[i - 1][j];
            if (minl[val] != j) gg[val].push_back(a[i - 1][val]);
        }
        vector <int> dp(n);
        for (int j = 0; j < n; ++j) {
            dp[a[i][j]] = j;
        }
        vector <int> used(n);
        for (int j = 0; j < n; ++j) {
            if (!used[j]) {
                calc_dp(j, gg, dp, used);
            }
        }

        minl = dp;
    }

    vector <vector <int>> g(n);
    for (int i = 0; i < n; ++i) {
        if (minl[a[k - 1][i]] < i) {
            g[a[k - 1][i]].push_back(a[k - 1][i - 1]);
            g[a[k - 1][i - 1]].push_back(a[k - 1][i]);
        }
    }
    vector <int> used(n);
    vector <int> sz(n);

    for (int i = 0; i < n; ++i) {
        st.clear();
        if (!used[i]) {
            dfs(i, g, used);
            for (int j : st) {
                sz[j] = st.size();
            }
        }
    }

    vector <vector <int>> lens(k);
    vector <vector <int>> psum(k);
    vector <vector <ll>> psum2(k);

    for (int i = 0; i < k; ++i) {
        int jj = n - 1;

        while (jj >= 0) {
            lens[i].push_back(sz[a[i][jj]]);
            jj -= sz[a[i][jj]];
        }
        reverse(lens[i].begin(), lens[i].end());
        int ln = lens[i].size();
        psum[i].resize(ln + 1);
        for (int j = 0; j < ln; ++j) {
            psum[i][j + 1] = psum[i][j] + lens[i][j];
        }
        psum2[i].resize(ln + 1);
        for (int j = 0; j < ln; ++j) {
            psum2[i][j + 1] = psum2[i][j] + 1ll * lens[i][j] * (lens[i][j] - 1) / 2;
        }
    }

    ll v = 0;

    while (q--) {
        int id, l, r;
        cin >> id >> l >> r;
        id = (id + v) % k;
        l = (l + v) % n;
        r = (r + v) % n;

        auto it_l = lower_bound(psum[id].begin(), psum[id].end(), l);
        auto it_r = lower_bound(psum[id].begin(), psum[id].end(), r + 1);
        ll len = r - l + 1;
        ll cur_val = 0;

        if (it_l == it_r) {
            cout << len * (len - 1) / 2 << "\n";
            v = len * (len - 1) / 2;
            continue;
        }

        cur_val += psum2[id][it_r - psum[id].begin() - 1] - psum2[id][it_l - psum[id].begin()];
        ll len_l = *it_l - l;
        ll len_r = (r + 1) - *(it_r - 1);

        cur_val += len_l * (len_l - 1) / 2;
        cur_val += len_r * (len_r - 1) / 2;
        v = cur_val;
        cout << cur_val << "\n";
    }
}

signed main() {
    if (1) {
        ios_base::sync_with_stdio(false);
        cin.tie(nullptr);
    }
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

/*
2
5 2 2
1 2 3 4 5
5 4 3 2 1
1 0 2
1 2 1
5 3 3
1 2 3 4 5
1 3 2 4 5
1 2 3 5 4
0 0 2
0 2 3
1 0 3
 */