#include <iostream>
#include <vector>
#include <deque>
#include <fstream>
#include <tuple>
#include <algorithm>

using namespace std;

void preprocessRowMax(const vector<vector<int>>& productivitate, vector<vector<int>>& rowMax, int N, int k) {
    for (int i = 0; i < N; ++i) {
        deque<int> dq;
        for (int j = 0; j < N; ++j) {
            while (!dq.empty() && dq.front() <= j - k) {
                dq.pop_front();
            }
            while (!dq.empty() && productivitate[i][dq.back()] <= productivitate[i][j]) {
                dq.pop_back();
            }
            dq.push_back(j);
            if (j >= k - 1) {
                rowMax[i][j - k + 1] = productivitate[i][dq.front()];
            }
        }
    }
}

vector<int> answerQueries(const vector<vector<int>>& rowMax, const vector<tuple<int, int, int>>& interogari, int N, int M) {
    vector<int> rezultate(M);
    for (int idx = 0; idx < M; ++idx) {
        int x, y, k;
        tie(x, y, k) = interogari[idx];

        deque<int> dq;
        for (int i = 0; i < k; ++i) {
            while (!dq.empty() && dq.front() <= i - k) {
                dq.pop_front();
            }
            while (!dq.empty() && rowMax[dq.back()][y] <= rowMax[i][y]) {
                dq.pop_back();
            }
            dq.push_back(i);
        }

        int maxValue = rowMax[dq.front()][y];
        for (int i = k; i < N - x; ++i) {
            while (!dq.empty() && dq.front() <= i - k) {
                dq.pop_front();
            }
            while (!dq.empty() && rowMax[dq.back()][y] <= rowMax[i][y]) {
                dq.pop_back();
            }
            dq.push_back(i);

            maxValue = max(maxValue, rowMax[dq.front()][y]);
        }
        rezultate[idx] = maxValue;
    }
    return rezultate;
}

int main() {
    ifstream fin("plantatie.in");
    ofstream fout("plantatie.out");

    int N, M;
    fin >> N >> M;
    vector<vector<int>> productivitate(N, vector<int>(N));

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            fin >> productivitate[i][j];
        }
    }

    vector<tuple<int, int, int>> interogari(M);
    for (int i = 0; i < M; ++i) {
        int x, y, k;
        fin >> x >> y >> k;
        interogari[i] = make_tuple(x - 1, y - 1, k);
    }

    vector<vector<int>> rowMax(N, vector<int>(N - N + 1));
    preprocessRowMax(productivitate, rowMax, N, N);

    vector<int> rezultate = answerQueries(rowMax, interogari, N, M);

    for (const int& rezultat : rezultate) {
        fout << rezultat << '\n';
    }

    fin.close();
    fout.close();
    return 0;
}