#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using i128 = __int128;
using u128 = unsigned __int128;
template <typename T>
void chkmax(T &x, const T &y) {
  if (x < y) x = y;
}
template <typename T>
void chkmin(T &x, const T &y) {
  if (y < x) x = y;
}
struct node {
  pair<int, int> rg[2];
  int id;
};
constexpr int MAXN = 505, MAXQ = 3e5 + 10, INF = 0x3f3f3f3f;
int n, cst[2][MAXN], val[2][MAXN][MAXN], ans[MAXQ];
int dpl[MAXN][MAXN][2][2], dpr[MAXN][MAXN][2][2];
int get_max(int ar[2][2]) { return *max_element(ar[0], ar[0] + 4); }
template <int t>
void solve(int l1, int r1, int l2, int r2, const vector<node> &qry) {
  if (r1 - l1 < r2 - l2) {
    solve<!t>(l2, r2, l1, r1, qry);
    return;
  }
  if (l1 == r1) {
    for (auto &i : qry) {
      int mx = -cst[t][l1];
      for (int j = i.rg[!t].first; j <= i.rg[!t].second; ++j)
        mx += max(val[t][l1][j] - cst[!t][j], 0);
      ans[i.id] = max(mx, 0);
    }
    return;
  }
  int mid = (l1 + r1) >> 1;
  vector<node> qryl, qryr, now;
  for (auto &i : qry) {
    if (i.rg[t].second <= mid) {
      qryl.emplace_back(i);
    } else if (i.rg[t].first > mid) {
      qryr.emplace_back(i);
    } else {
      now.emplace_back(i);
    }
  }
  solve<t>(l1, mid, l2, r2, qryl);
  solve<t>(mid + 1, r1, l2, r2, qryr);
  if (now.empty()) return;
  for (int s = l2; s <= r2; ++s) {
    for (int have = 0; have < 2; ++have) {
      for (int x = l1; x <= mid; ++x)
        for (int y = l2; y <= s; ++y) fill_n(dpl[x][y][0], 4, -INF);
      dpl[mid][s][0][have] = 0;
      dpl[mid][s][1][have] = (have ? val[t][mid][s] : 0) - cst[t][mid];
      for (int x = mid; x >= l1; --x) {
        for (int y = s; y >= l2; --y) {
          int tmp = max(dpl[x][y][0][0], dpl[x][y][1][0]);
          chkmax(dpl[x - 1][y][0][0], tmp);
          chkmax(dpl[x - 1][y][1][0], tmp - cst[t][x - 1]);
          tmp = max(dpl[x][y][0][0], dpl[x][y][0][1]);
          chkmax(dpl[x][y - 1][0][0], tmp);
          chkmax(dpl[x][y - 1][0][1], tmp - cst[!t][y - 1]);
          tmp = max(dpl[x][y][0][1], dpl[x][y][1][1]);
          chkmax(dpl[x - 1][y][0][1], tmp);
          chkmax(dpl[x - 1][y][1][1], tmp + val[t][x - 1][y] - cst[t][x - 1]);
          tmp = max(dpl[x][y][1][0], dpl[x][y][1][1]);
          chkmax(dpl[x][y - 1][1][0], tmp);
          chkmax(dpl[x][y - 1][1][1], tmp + val[t][x][y - 1] - cst[!t][y - 1]);
        }
      }
      for (int x = mid + 1; x <= r1; ++x)
        for (int y = s; y <= r2; ++y) fill_n(dpr[x][y][0], 4, -INF);
      dpr[mid + 1][s][0][have] = 0;
      dpr[mid + 1][s][1][have] =
          (have ? val[t][mid + 1][s] : 0) - cst[t][mid + 1];
      for (int x = mid + 1; x <= r1; ++x) {
        for (int y = s; y <= r2; ++y) {
          int tmp = max(dpr[x][y][0][0], dpr[x][y][1][0]);
          chkmax(dpr[x + 1][y][0][0], tmp);
          chkmax(dpr[x + 1][y][1][0], tmp - cst[t][x + 1]);
          tmp = max(dpr[x][y][0][0], dpr[x][y][0][1]);
          chkmax(dpr[x][y + 1][0][0], tmp);
          chkmax(dpr[x][y + 1][0][1], tmp - cst[!t][y + 1]);
          tmp = max(dpr[x][y][0][1], dpr[x][y][1][1]);
          chkmax(dpr[x + 1][y][0][1], tmp);
          chkmax(dpr[x + 1][y][1][1], tmp + val[t][x + 1][y] - cst[t][x + 1]);
          tmp = max(dpr[x][y][1][0], dpr[x][y][1][1]);
          chkmax(dpr[x][y + 1][1][0], tmp);
          chkmax(dpr[x][y + 1][1][1], tmp + val[t][x][y + 1] - cst[!t][y + 1]);
        }
      }
      for (auto &i : now) {
        if (i.rg[!t].first <= s && i.rg[!t].second >= s) {
          chkmax(ans[i.id], get_max(dpl[i.rg[t].first][i.rg[!t].first]) +
                                get_max(dpr[i.rg[t].second][i.rg[!t].second]) -
                                (have ? cst[!t][s] : 0));
        }
      }
    }
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int q;
  cin >> n >> q;
  for (int t = 0; t < 2; ++t)
    for (int i = 1; i <= n; ++i) cin >> cst[t][i];
  for (int i = 1; i <= n; ++i) {
    for (int j = 1; j <= n; ++j) {
      cin >> val[0][i][j];
      val[1][j][i] = val[0][i][j];
    }
  }
  vector<node> qry(q);
  for (int i = 0; i < q; ++i) {
    cin >> qry[i].rg[0].first >> qry[i].rg[0].second >> qry[i].rg[1].first >>
        qry[i].rg[1].second;
    qry[i].id = i;
  }
  solve<0>(1, n, 1, n, qry);
  for (int i = 0; i < q; ++i) cout << ans[i] << "\n";
  return 0;
}
/*
g++ L.cpp -o L -std=c++14 -O2 -Wall -Wextra -Wshadow -g
-fsanitize=address,undefined
*/