/*
__
/\ \
_ __ ___ ___\ \ \/'\ ___ __ ___ ___ __
/\`'__\/ __`\ /'___\ \ , < / __`\ /'__`\ /' _ `\ /' _ `\ /'__`\
\ \ \//\ \L\ \/\ \__/\ \ \\`\ /\ \L\ \/\ \L\.\_/\ \/\ \/\ \/\ \/\ \L\.\_
\ \_\\ \____/\ \____\\ \_\ \_\ \____/\ \__/.\_\ \_\ \_\ \_\ \_\ \__/.\_\
\/_/ \/___/ \/____/ \/_/\/_/\/___/ \/__/\/_/\/_/\/_/\/_/\/_/\/__/\/_/
{1}
{1}
*/
#ifndef __AHA__HEADER
#define __AHA__HEADER
#include <bits/stdc++.h>
using namespace std;
#define g0 get<0>
#define g1 get<1>
#define g2 get<2>
#define ft first
#define sd second
#define sz(x) (i6) x.size()
#define psb(x) push_back(x)
#define ppb() pop_back()
#define bg(x) x.begin()
#define ed(x) x.end()
#define col(x) x.begin(), x.end()
#define srt(x) sort(x.begin(), x.end())
#define pq priority_queue
#define fn function
#ifdef LOCAL
#define git stauDBG_MACRO_NO_WARNING
#include <dbg.h>
#else
#define dbg(...)
#endif
#define endl '\n'
template <typename T>
using vec = vector<T>;
template <typename T>
using deq = deque<T>;
template <typename K, typename V>
using hmap = unordered_map<K, V>;
using str = string;
using vb = vec<bool>;
using byte = int8_t;
using i3 = int32_t;
using i6 = int32_t;
using i66 = int64_t;
using i64 = int32_t;
using u3 = uint32_t;
using u6 = uint64_t;
using d6 = long double;
using p3 = pair<i3, i3>;
using vi3 = vec<i3>;
using vp3 = vec<p3>;
using p6 = pair<i6, i6>;
using vi6 = vec<i6>;
using vd6 = vec<d6>;
using vp6 = vec<p6>;
using vv = vec<vi6>;
using dp6 = deq<p6>;
using di6 = deq<i6>;
using mi6 = map<i6, i6>;
using mp6 = map<p6, i6>;
using si6 = set<i6>;
using hi6 = hmap<i6, i6>;
using bs = bitset<64>;
using graph = vv;
using matrix = vv;
const d6 EPS = 1 / 1000000.0;
const i66 ZERO = 0;
const i66 _0 = ZERO;
const i66 ONE = 1;
const i66 _1 = ONE;
const i66 INF = INT64_MAX / 4;
const i66 NINF = -INF;
namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2>> {
std::size_t operator()(const pair<T1, T2>& pair) const noexcept {
return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
}
};
} // namespace std
template <typename T1, typename T2>
istream& operator>>(istream& stream, pair<T1, T2>& p) {
stream >> p.ft;
stream >> p.sd;
return stream;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& stream, const pair<T1, T2>& p) {
return stream << p.ft << " " << p.sd;
}
template <typename T>
istream& operator>>(istream& stream, vec<T>& v) {
if (v.empty()) {
u6 len;
stream >> len;
v.assign(len, T());
}
for (auto i = 0; i < sz(v); i++) {
stream >> v[i];
}
return stream;
}
template <typename T>
ostream& operator<<(ostream& stream, const vec<T>& v) {
if (!v.empty()) {
stream << v[0];
}
for (auto i = 1; i < sz(v); i++) {
stream << " " << v[i];
}
return stream;
}
template <typename T>
istream& operator>>(istream& stream, deq<T>& v) {
if (v.empty()) {
u6 len;
stream >> len;
v.assign(len, T());
}
for (auto i = 0; i < sz(v); i++) {
stream >> v[i];
}
return stream;
}
template <typename T>
ostream& operator<<(ostream& stream, const deq<T>& v) {
if (!v.empty()) {
stream << v[0];
}
for (auto i = 1; i < sz(v); i++) {
stream << " " << v[i];
}
return stream;
}
#endif
const i6 MAX_POW2_SIGNED = 31;
inline i66 le_pow2(i6 n) {
i66 ans = ONE << MAX_POW2_SIGNED;
while (n < ans) {
ans >>= 1;
}
return ans;
}
inline i6 le_log2(i6 n) {
i6 ans = MAX_POW2_SIGNED;
i66 val = ONE << ans;
while (n < val) {
ans--;
val = ONE << ans;
}
return ans;
}
class spt {
public:
int table[11][501];
i6 len;
spt(i64 lenn) {
len = lenn;
// table = vv(k, vi6(len));
// for (i6 j = 0; j < len; j++) {
// table[0][j] = arr[j];
// }
}
inline void build() {
i6 k = le_log2(len) + 1;
for (i6 i = 1; i < k; i++) {
i6 pi = ONE << i;
for (i6 j = 0; j + pi <= len; j++) {
table[i][j] = max(table[i - 1][j], table[i - 1][j + (ONE << (i - 1))]);
}
}
}
inline i6 rmq(i6 l, i6 r) {
i6 k = le_log2(r - l + 1);
return max(table[k][l], table[k][r - (ONE << k) + 1]);
}
};
inline i6 nexp2(i6 n) {
i6 res = 1;
while ((i6)res < n) {
res = res * 2;
}
return res;
}
i64 n, m;
int v[501][501];
class segtree2d {
private:
u6 offset;
vec<spt> data;
public:
segtree2d() {
offset = nexp2(n);
data.assign(offset * 2, spt(n));
build();
}
inline void build() {
i64 si = offset;
i64 p = 1;
while (si > 0) {
i64 j = 0;
for (i64 i = si; i < 2 * si; i++) {
for (i64 jj = 0; jj < n; jj++) {
int* x = &data[i].table[0][jj];
for (i64 ii = j; ii < min(j + p, (i64)n); ii++) {
*x = max(*x, v[ii][jj]);
}
}
// cout << data[i].data << endl;
data[i].build();
j += p;
}
si /= 2;
p *= 2;
}
}
i6 rmq(i64 idx, p6 x, p6 y, p6 lr) {
if (x.ft == lr.ft && x.sd == lr.sd) {
// dbg(lr, y, data[idx].rmq(y.ft, y.sd));
return data[idx].rmq(y.ft, y.sd);
}
i64 res = 0;
i64 mid = lr.ft + (lr.sd - lr.ft) / 2;
if (x.ft <= mid) {
res = max(res, rmq(2 * idx, {x.ft, min(x.sd, mid)}, y, {lr.ft, mid}));
}
if (x.sd > mid) {
res = max(res, rmq(2 * idx + 1, {max(mid + 1, x.ft), x.sd}, y,
{mid + 1, lr.sd}));
}
return res;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// #ifdef LOCAL
ifstream cin{"plantatie.in"};
ofstream cout{"plantatie.out"};
// #endif
std::istream_iterator<int> iit(cin);
n = *iit;
iit++;
m = *iit;
iit++;
// cin >> n >> m;
for (i64 i = 0; i < n; i++) {
for (i64 j = 0; j < n; j++) {
// cin >> v[i][j];
v[i][j] = *iit;
iit++;
}
}
segtree2d s;
i64 x1, y1, k;
for (i64 i = 0; i < m; i++) {
// cin >> x1 >> y1 >> k;
x1 = *iit;
iit++;
y1 = *iit;
iit++;
k = *iit;
iit++;
x1--;
y1--;
k--;
cout << s.rmq(1, {x1, x1 + k}, {y1, y1 + k}, {0, (i64)nexp2(n) - (i64)1})
<< '\n';
}
return 0;
}