#include <iostream>
#include <fstream>
#include <algorithm>

#define MAXN 500

int n, m;
int v[1 + 8 * MAXN * MAXN];

void set_elem(int node, int ri, int rf, int ci, int cf, int r, int c, int val) {
  if (ri > rf || ci > cf) return;

  if (r < ri || r > rf || c < ci || c > cf) return;

  if (r >= ri && r <= rf && c >= ci && c <= cf)
    v[node] = (val > v[node] ? val : v[node]);

  if (ri == rf && ci == cf) return;

  int rm = (ri + rf) / 2;
  int cm = (ci + cf) / 2;
  if (r <= rm) {
    if (c <= cm) {
      set_elem(node * 4 - 2, ri, rm, ci, cm, r, c, val);
    } else {
      set_elem(node * 4 - 1, ri, rm, cm + 1, cf, r, c, val);
    }
  } else {
    if (c <= cm) {
      set_elem(node * 4 - 0, rm + 1, rf, ci, cm, r, c, val);
    } else {
      set_elem(node * 4 + 1, rm + 1, rf, cm + 1, cf, r, c, val);
    }
  }
}

int get_elem(int node, int ri, int rf, int ci, int cf,
              int rqi, int rqf, int cqi, int cqf) {
  // No overlap.
  if (ri > rf || ci > cf) return 0;
  if (rqf < ri || rqi > rf || cqf < ci || cqf > cf) return 0;

  // Complete inclusion.
  if (rqi <= ri && rqf >= rf && cqi <= ci && cqf >= cf) {
    return v[node];
  }

  // Break it up.
  int rm = (ri + rf) / 2;
  int cm = (ci + cf) / 2;
  return std::max(
      std::max(
          get_elem(node * 4 - 2, ri, rm, ci, cm, rqi, rqf, cqi, cqf),
          get_elem(node * 4 - 1, ri, rm, cm + 1, cf, rqi, rqf, cqi, cqf)),
      std::max(
          get_elem(node * 4 - 0, rm + 1, rf, ci, cm, rqi, rqf, cqi, cqf),
          get_elem(node * 4 + 1, rm + 1, rf, cm + 1, cf, rqi, rqf, cqi, cqf)));
}

inline void set(int r, int c, int val) {
  set_elem(1, 1, n, 1, n, r, c, val);
}

inline int get(int rqi, int rqf, int cqi, int cqf) {
  return get_elem(1, 1, n, 1, n, rqi, rqf, cqi, cqf);
}

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

  int x;
  in >> n >> m;
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
      in >> x;
      set(i, j, x);
    }
  }

  for (int i = 0; i < m; ++i) {
    int ri, ci, s;
    in >> ri >> ci >> s;
    out << get(ri, ri + s - 1, ci, ci + s - 1) << std::endl;
  }

  in.close();
  out.close();

  return 0;
}