/*
                    __
                   /\ \
 _ __   ___     ___\ \ \/'\     ___      __      ___     ___      __
/\`'__\/ __`\  /'___\ \ , <    / __`\  /'__`\  /' _ `\ /' _ `\  /'__`\
\ \ \//\ \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;
  }

  i6 rmqi(i6 left, i6 right, p6 y) {
    left += offset;
    right += offset + 1;

    i6 res_l = 0;
    i6 res_r = 0;

    while (left < right) {
      if (left % 2 == 1) {
        res_l = max(res_l, data[left++].rmq(y.ft, y.sd));
      }

      if (right % 2 == 1) {
        res_r = max(data[--right].rmq(y.ft, y.sd), res_r);
      }
      left /= 2;
      right /= 2;
    }
    return max(res_l, res_r);
  }
};

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  // #ifdef LOCAL
  ifstream cin{"plantatie.in"};
  ofstream cout{"plantatie.out"};
  // #endif

  cin >> n >> m;
  for (i64 i = 0; i < n; i++) {
    for (i64 j = 0; j < n; j++) {
      cin >> v[i][j];
    }
  }

  segtree2d s;

  for (i64 i = 0; i < m; i++) {
    i64 x1, y1, k;
    cin >> x1 >> y1 >> k;
    x1--;
    y1--;
    k--;

    cout << s.rmqi(x1, x1 + k, {y1, y1 + k}) << '\n';
  }

  return 0;
}