#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

ifstream f("plantatie.in");
ofstream g("plantatie.out");

const int MAX_N = 500; // Ajustează la maximul specificat în problema ta
int max_table[MAX_N][MAX_N][10]; // 2^9 este cea mai mare putere a lui 2 care nu depășește 500
int log2_lookup[MAX_N + 1];

void build_log_lookup(int n) {
    log2_lookup[1] = 0;
    for (int i = 2; i <= n; i++) {
        log2_lookup[i] = log2_lookup[i / 2] + 1;
    }
}

void build_sparse_table(int n, vector<vector<int>>& mat) {
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            max_table[i][j][0] = mat[i][j];

    for (int r = 1; (1 << r) <= n; r++) {
        int size = 1 << r;
        int half = size >> 1;
        for (int i = 0; i + size - 1 < n; i++) {
            for (int j = 0; j + size - 1 < n; j++) {
                max_table[i][j][r] = max(max(max_table[i][j][r-1], max_table[i + half][j][r-1]),
                                         max(max_table[i][j + half][r-1], max_table[i + half][j + half][r-1]));
            }
        }
    }
}

int query_max(int x, int y, int k, int n) {
    int r = log2_lookup[k];
    int max_val = 0;
    max_val = max(max_val, max_table[x][y][r]);
    max_val = max(max_val, max_table[x][y + k - (1 << r)][r]);
    max_val = max(max_val, max_table[x + k - (1 << r)][y][r]);
    max_val = max(max_val, max_table[x + k - (1 << r)][y + k - (1 << r)][r]);
    return max_val;
}

int main() {
    int n, m;
    f >> n >> m;
    vector<vector<int>> mat(n, vector<int>(n));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            f >> mat[i][j];

    build_log_lookup(n);
    build_sparse_table(n, mat);

    while (m--) {
        int i, j, k;
        f >> i >> j >> k;
        i--; j--; // Ajustează la indexare 0-based
        g << query_max(i, j, k, n) << '\n';
    }

    return 0;
}