#include <bits/stdc++.h>

//#include <atcoder/all>
using namespace std;

#define lli long long int
#define REP(i, s, n) for (lli i = s; i < n; i++)
#define INF (1LL << 62)
#define mp(a, b) make_pair(a, b)
#define SORT(V) sort(V.begin(), V.end())
#define PI (3.141592653589794)
#define TO_STRING(VariableName) #VariableName
#define LOG1(x)                                                                \
  if (DEBUG)                                                                   \
    cout << TO_STRING(x) << "=" << x << " " << endl;
#define LOG2(x, y)                                                             \
  if (DEBUG)                                                                   \
    cout << TO_STRING(x) << "=" << x << " " << TO_STRING(y) << "=" << y << endl;
#define LOG3(x, y, z)                                                          \
  if (DEBUG)                                                                   \
    cout << TO_STRING(x) << "=" << x << " " << TO_STRING(y) << "=" << y << " " \
         << TO_STRING(z) << "=" << z << endl;
#define LOG4(w, x, y, z)                                                       \
  if (DEBUG)                                                                   \
    cout << TO_STRING(w) << "=" << w << " " << TO_STRING(x) << "=" << x << " " \
         << TO_STRING(y) << "=" << y << " " << TO_STRING(z) << "=" << z        \
         << endl;
#define LOG5(w, x, y, z, a)                                                    \
  if (DEBUG)                                                                   \
    cout << TO_STRING(w) << "=" << w << " " << TO_STRING(x) << "=" << x << " " \
         << TO_STRING(y) << "=" << y << " " << TO_STRING(z) << "=" << z << " " \
         << TO_STRING(a) << "=" << a << endl;
#define LOG6(w, x, y, z, a, b)                                                 \
  if (DEBUG)                                                                   \
    cout << TO_STRING(w) << "=" << w << " " << TO_STRING(x) << "=" << x << " " \
         << TO_STRING(y) << "=" << y << " " << TO_STRING(z) << "=" << z << " " \
         << TO_STRING(a) << "=" << a << " " << TO_STRING(b) << "=" << b        \
         << endl;

#define overload6(a, b, c, d, e, f, g, ...) g
#define LOG(...)                                                               \
  overload6(__VA_ARGS__, LOG6, LOG5, LOG4, LOG3, LOG2, LOG1)(__VA_ARGS__)

template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}

mt19937 engine;
std::chrono::system_clock::time_point start, endTime;

#define DEBUG 1

// checker https://atcoder.jp/contests/abc264/tasks/abc264_e

struct UnionFind {
  vector<int> par; // par[i]:iの親の番号　(例) par[3] = 2 : 3の親が2
  vector<bool> isOk;
  vector<lli> siz; // 素集合のサイズを表す配列(1 で初期化)
  lli N;

  UnionFind(int N)
      : par(N), isOk(N), siz(N) { //最初は全てが根であるとして初期化
    for (int i = 0; i < N; i++) {
      par[i] = i;
      isOk[i] = false;
      siz[i] = 1;
    }

    this->N = N;
  }

  int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
    if (par[x] == x)
      return x;
    return par[x] = root(par[x]);
  }

  void setOk(lli i) { isOk[i] = isOk[root(i)] = true; }

  bool isCheckOk(lli i) { return isOk[root(i)]; }
  void unite(int x, int y) { // xとyの木を併合
    int rx = root(x);        // xの根をrx
    int ry = root(y);        // yの根をry
    if (rx == ry)
      return; // xとyの根が同じ(=同じ木にある)時はそのまま

    if (siz[rx] < siz[ry])
      swap(rx, ry);
    siz[rx] += siz[ry];
    par[ry] =
        rx; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
    if (isOk[rx] || isOk[ry]) {
      isOk[ry] = true;
      isOk[rx] = true;
    }
  }

  bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
    int rx = root(x);
    int ry = root(y);
    return rx == ry;
  }
  lli size(lli x) { return siz[root(x)]; }
};

static const int max_n = 1 << 15; //数列a_iの最大の要素数を設定する
int seg_tree[2 * max_n];
int n;

//初期化を行う関数
void init(int n_) {
  //完全二分木にするため、データ数を2の倍数にする。
  n = 1;
  while (n < n_)
    n *= 2;

  // RMQを考えたいので、セグ木の各値はINT_MAXに設定しておく
  REP(i, 0, 2 * n) seg_tree[i] = 0;
}

// index番目の値をxに変更する関数
void update(int index, int x) {
  index +=
      n - 1; //最も下のレイヤーにおいて、1番目の値はseg_treeの中ではn番目だから
  seg_tree[index] = x;
  while (index > 0) {
    index = (index - 1) / 2; //親のノードのindex
    seg_tree[index] = max(seg_tree[2 * index + 1], seg_tree[2 * index + 2]);
  }
}

//区間[a,b)における最小値を求める関数
// indexはseg_treeにおける番号で、left,rightはseg_tree[index]の区間に対応
// query(a,b,0,0,n)として呼ぶことを考える。
int query(int a, int b, int index, int left, int right) {
  //考えようとしている区間が、[a,b)に全く含まれないなら、INT_MAXを返して、操作に影響しないようにする。
  if (a >= right || b <= left)
    return 0;

  //考えようとしている区間が[a,b)に完全に含まれているなら、その値を返せばよい。
  if (a <= left && b >= right)
    return seg_tree[index];

  //どちらでもない場合、seg_tree[index]の2つの子ノードに対して再帰的に操作を行う。
  int value_1 = query(a, b, 2 * index + 1, left, (left + right) / 2);
  int value_2 = query(a, b, 2 * index + 2, (left + right) / 2, right);
  return max(value_1, value_2);
}

lli a[800][800];
lli di[2] = {1, 0};
lli dj[2] = {0, 1};
lli H, W;

//オイラーツアーを行う。
// eulerNodeには、オイラーツアーで通った頂点が格納される。
void eulerDfs(lli now, lli from, const vector<vector<lli>> &Graph,
              vector<lli> &eulerNode) {
  eulerNode.push_back(now);
  for (auto next : Graph[now]) {
    if (next == from)
      continue;
    eulerDfs(next, now, Graph, eulerNode);
    eulerNode.push_back(now);
  }
}

void solve() {
  //  write your code here

  cin >> H >> W;

  REP(i, 0, H) {
    REP(j, 0, W) { cin >> a[i][j]; }
  }

  using P = pair<lli, pair<lli, lli>>;
  priority_queue<P, vector<P>, greater<P>> pq;

  lli maxA = 0;

  REP(i, 0, H) {
    REP(j, 0, W) {
      REP(dir, 0, 2) {
        lli ni = i + di[dir];
        lli nj = j + dj[dir];
        if (ni < H && nj < W) {
          pq.push({max(a[i][j], a[ni][nj]), {i * W + j, ni * W + nj}});
          chmax(maxA, max(a[i][j], a[ni][nj]));
        }
      }
    }
  }

  lli Q;
  cin >> Q;

  vector<pair<lli, lli>> query;
  REP(i, 0, Q) {
    lli i1, j1, i2, j2;
    cin >> i1 >> j1 >> i2 >> j2;
    i1--;
    j1--;
    i2--;
    j2--;
    query.push_back({i1 * W + j1, i2 * W + j2});
  }

  vector<lli> ans(Q, -1);
  vector<pair<lli, lli>> querySmallAndLarge;
  REP(i, 0, Q) { querySmallAndLarge.push_back({0, maxA + 1}); }
  while (true) {
    //各クエリについて今回のターゲットを決める
    priority_queue<pair<lli, lli>, vector<pair<lli, lli>>,
                   greater<pair<lli, lli>>>
        pq2;
    bool update = false;
    REP(i, 0, Q) {
      if (querySmallAndLarge[i].first + 1 < querySmallAndLarge[i].second) {
        update = true;
        pq2.push(
            {(querySmallAndLarge[i].first + querySmallAndLarge[i].second) / 2,
             i});
      } else {
        ans[i] = querySmallAndLarge[i].second;
      }
    }
    if (!update)
      break;
    auto nowPQ = pq;
    UnionFind uf(H * W);
    REP(i, 0, maxA + 1) {
      while (nowPQ.size() && nowPQ.top().first <= i) {
        auto now = nowPQ.top();
        nowPQ.pop();

        lli nowCost = now.first;
        auto firstP = now.second.first;
        auto secondP = now.second.second;
        if (!uf.same(firstP, secondP)) {
          uf.unite(firstP, secondP);
        }
      }
      while (pq2.size() && pq2.top().first == i) {
        auto now = pq2.top();
        pq2.pop();
        lli queryNum = now.second;
        lli target = now.first;
        if (uf.same(query[queryNum].first, query[queryNum].second)) {
          // ans[queryNum] = target;
          querySmallAndLarge[queryNum].second = target;
        } else {
          querySmallAndLarge[queryNum].first = target;
        }
      }
    }
  }
  REP(i, 0, Q) { cout << ans[i] << endl; }
}

// Generated by 2.13.0 https://github.com/kyuridenamida/atcoder-tools  (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
  // Failed to predict input format

  lli N = 1;
  // cin >> N;
  while (N--)
    solve();

  return 0;
}