#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, INF = 0x3f3f3f3f;
int n, cst[2][MAXN], val[2][MAXN][MAXN], ans[MAXN];
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); }
void solve(int t, int l1, int r1, int l2, int r2, const vector<node> &qry) {
  if (r1 - l1 > r2 - l2) {
    swap(l1, l2);
    swap(r1, r2);
    t ^= 1;
  }
  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) {
    if (all_of(now.begin(), now.end(), [&](const node &x) {
          return x.rg[!t].first > s || x.rg[!t].second < s;
        })) {
      continue;
    }
    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) {
          for (int tx = 0; tx < 2; ++tx) {
            for (int ty = 0; ty < 2; ++ty) {
              if (dpl[x][y][tx][ty] == -INF) continue;
              if (x != l1) {
                chkmax(dpl[x - 1][y][0][ty], dpl[x][y][tx][ty]);
                chkmax(dpl[x - 1][y][1][ty], dpl[x][y][tx][ty] +
                                                 (ty ? val[t][x - 1][y] : 0) -
                                                 cst[t][x - 1]);
              }
              if (y != l2) {
                chkmax(dpl[x][y - 1][tx][0], dpl[x][y][tx][ty]);
                chkmax(dpl[x][y - 1][tx][1], dpl[x][y][tx][ty] +
                                                 (tx ? val[t][x][y - 1] : 0) -
                                                 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) {
          for (int tx = 0; tx < 2; ++tx) {
            for (int ty = 0; ty < 2; ++ty) {
              if (dpr[x][y][tx][ty] == -INF) continue;
              if (x != r1) {
                chkmax(dpr[x + 1][y][0][ty], dpr[x][y][tx][ty]);
                chkmax(dpr[x + 1][y][1][ty], dpr[x][y][tx][ty] +
                                                 (ty ? val[t][x + 1][y] : 0) -
                                                 cst[t][x + 1]);
              }
              if (y != r2) {
                chkmax(dpr[x][y + 1][tx][0], dpr[x][y][tx][ty]);
                chkmax(dpr[x][y + 1][tx][1], dpr[x][y][tx][ty] +
                                                 (tx ? val[t][x][y + 1] : 0) -
                                                 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));
          if (i.id == 900) {
            cout << i.rg[t].first << " " << i.rg[t].second << " "
                 << i.rg[!t].first << " " << i.rg[!t].second << " QAQ\n";
            cout << s << " " << 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] << "\n";
          }
        }
      }
    }
  }
}
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
*/