#include <fstream>


int n, t, v[100][100], rmq[9][505][505], log2[505], i, j, k;


int main() {

    std::ifstream fin("plantatie.in");

    std::ofstream fout("plantatie.out");

    fin >> n >> t;

    for (int i = 1; i <= n; i++) {

        for (int j = 1; j <= n; j++) {

            fin >> rmq[0][i][j];

        }

    }

    for (int k = 1; (1 << k) <= n; k++) {

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

            for (int j = 1; j <= n - (1 << k) + 1; j++) {

                rmq[k][i][j] = std::max(std::max(rmq[k - 1][i][j], rmq[k - 1][i + (1 << k - 1)][j]),
                                        std::max(rmq[k - 1][i][j + (1 << k - 1)],
                                                 rmq[k - 1][i + (1 << k - 1)][j + (1 << k - 1)]));

            }

        }

    }

    for (int i = 2; i <= n; i++) {

        log2[i] = log2[i / 2] + 1;

    }

    while (t--) {

        fin >> i >> j >> k;

        fout << std::max(std::max(rmq[log2[k]][i][j], rmq[log2[k]][i + k - (1 << log2[k])][j + k - (1 << log2[k])]),
                         std::max(rmq[log2[k]][i][j + k - (1 << log2[k])], rmq[log2[k]][i + k - (1 << log2[k])][j]))
             << '\n';

    }

    return 0;

}


/*
#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>

template<class T>
class Range_minimum_query {
public:
    explicit Range_minimum_query(std::vector<std::vector<T>> &arr);

    T query(int i, int j, int k);

private:
    std::vector<std::vector<std::vector<T>>> lookup;
    std::vector<int> lg2;
};

template<class T>
Range_minimum_query<T>::Range_minimum_query(std::vector<std::vector<T>> &arr) {
    lookup.resize(log2(arr.size()) + 1, std::vector<std::vector<T>>(arr.size(), std::vector<T>(arr.size())));
    for (int i = 0; i < arr.size(); i++) {
        for (int j = 0; j < arr.size(); j++) {
            lookup[0][i][j] = arr[i][j];
        }

    }
    for (int k = 1; (1 << k) <= arr.size(); k++) {
        for (int i = 0; i <= arr.size() - (1 << k); i++) {
            for (int j = 0; j <= arr.size() - (1 << k); j++) {
                lookup[k][i][j] = std::max(std::max(lookup[k - 1][i][j], lookup[k - 1][i + (1 << k - 1)][j]),
                                           std::max(lookup[k - 1][i][j + (1 << k - 1)],
                                                    lookup[k - 1][i + (1 << k - 1)][j + (1 << k - 1)]));
            }

        }

    }
    lg2.resize(arr.size());
    for (int i = 2; i < arr.size(); i++) {

        lg2[i] = lg2[i / 2] + 1;

    }
}

template<class T>
T Range_minimum_query<T>::query(int i, int j, int k) {
    //int lg = log2(j - i + 1);
    int t1 = lookup[lg2[k]][i][j];
    int t2 = lookup[lg2[k]][i + k - (1 << lg2[k])][j + k - (1 << lg2[k])];
    int t3 = lookup[lg2[k]][i][j + k - (1 << lg2[k])];
    int t4 = lookup[lg2[k]][i + k - (1 << lg2[k])][j];

    return std::max(std::max(t1, t2), std::max(t3, t4));
}

int main() {
    std::ifstream fin("plantatie.in");


    std::vector<std::vector<int>> a;
    int n, m;
    fin >> n >> m;
    a.resize(n, std::vector<int>(n, 0));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int g;
            fin >> g;
            std::cout << g << " ";
            a[i][j] = g;
        }
        std::cout << "\n";
    }


    std::ofstream fout("plantatie.out");
    Range_minimum_query<int> rmq(a);
    int f, g, h;
    for (int i = 0; i < m; i++) {
        fin >> f >> g >> h;
        fout << rmq.query(f - 1, g - 1, h) << "\n";
    }

    return 0;
}*/