/*
    __  ___        __
   /  |/  /____   / /_ ____   _____ ____ _ _____
  / /|_/ // __ \ / __// __ \ / ___// __ `// ___/
 / /  / // /_/ // /_ / /_/ // /   / /_/ /(__  )
/_/  /_/ \____/ \__/ \____//_/    \__,_//____/
*/
#ifndef __AHA__HEADER
#define __AHA__HEADER

#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define let auto
#define g0 get<0>
#define g1 get<1>
#define g2 get<2>
#define ft first
#define sd second
#define sz(x) (i8) x.size()
#define col(x) x.begin(), x.end()
#define srt(x) sort(x.begin(), x.end())
#define rsrt(x) sort(x.rbegin(), x.rend())
#define rvs(x) reverse(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 umap = unordered_map<K, V>;

template <typename K, typename V>
using hmap = cc_hash_table<K, V>;

using str = string;

using byte = int8_t;
using i2 = int16_t;
using i4 = int32_t;
using i8 = int64_t;
using i64 = int64_t;

using u2 = uint16_t;
using u4 = uint32_t;
using u8 = uint64_t;
using d8 = long double;

using p4 = pair<i4, i4>;
using p8 = pair<i8, i8>;
using pd = pair<d8, d8>;

using vb = vec<bool>;
using vi4 = vec<i4>;
using vp4 = vec<p4>;
using vi8 = vec<i8>;
using vd = vec<d8>;
using vp8 = vec<p8>;
using vpd = vec<pd>;

using vs = vec<str>;
using vv = vec<vi8>;

using dp8 = deq<p8>;
using di8 = deq<i8>;

using mi8 = map<i8, i8>;
using mp8 = map<p8, i8>;
using si8 = set<i8>;
using hi8 = hmap<i8, i8>;

using bs = bitset<64>;

using graph = vv;
using wgraph = vec<vp8>;
using matrix = vv;

const d8 EPS = 1 / 1000000.0;
const i8 ZERO = 0;
const i8 _0 = ZERO;
const i8 ONE = 1;
const i8 _1 = ONE;
const i8 INF = INT64_MAX / 4;
const i8 NINF = -INF;

namespace std {

vector<string> split(string line) {
  vector<string> res;
  istringstream iss(line);
  str crt;
  while (iss >> crt) {
    res.push_back(crt);
  }
  return res;
}

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()) {
    u8 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()) {
    u8 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;
}

template <typename T>
inline T pop(vector<T> &stack) {
  T top = stack.back();
  stack.pop_back();
  return top;
}

template <typename T>
inline T popb(deq<T> &que) {
  T top = que.back();
  que.pop_back();
  return top;
}

template <typename T>
inline T popf(deq<T> &que) {
  T top = que.front();
  que.pop_front();
  return top;
}
#endif

// https :  // www.spoj.com/problems/THRBL/

i4 rmq[10][502][502];
inline i4 l2(i4 val) { return 31 - __builtin_clz(val); }
inline i4 p2(i4 val) { return (1 << val); }

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

  i4 n, q;
  cin >> n >> q;

  for (i4 i = 0; i < n; i++) {
    for (i4 j = 0; j < n; j++) {
      cin >> rmq[0][i][j];
      dbg(rmq[0][i][j]);
    }
  }

  int ln = l2(n);
  for (int k = 1; k <= ln; k++) {
    int pp2 = p2(k - 1);
    for (int i = 0; i + pp2 < n; i++) {
      for (int j = 0; j + pp2 < n; j++) {
        rmq[k][i][j] =
            max({rmq[k - 1][i][j], rmq[k - 1][i + pp2][j],
                 rmq[k - 1][i][j + pp2], rmq[k - 1][i + pp2][j + pp2]});
      }
    }
  }

  for (i4 i = 0; i < q; i++) {
    i4 x, y, k;
    cin >> x >> y >> k;
    x -= 1;
    y -= 1;
    i4 ld = l2(k);
    i4 pld = p2(ld);
    i4 delta = k - pld;
    cout << max({rmq[ld][x][y], rmq[ld][x + delta][y], rmq[ld][x][y + delta],
                 rmq[ld][x + delta][y + delta]})
         << endl;
  }

  return 0;
}