#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
  double f = (double)rand() / RAND_MAX;
  return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
  return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
  return max(a, max(b, c));
}
struct Element {
  long long x;
  int ind;
  bool inline operator<(const Element &rhs) const { return x < rhs.x; }
};
struct IT {
 private:
  vector<Element> t;
  int n;
  void update(int id, int l, int r, const int &p, const Element &e) {
    if (l > p || r < p) return;
    if (l == p && r == p) {
      t[id] = e;
      return;
    }
    int m = (l + r) / 2;
    update(2 * id, l, m, p, e);
    update(2 * id + 1, m + 1, r, p, e);
    t[id] = max(t[2 * id], t[2 * id + 1]);
  }
  Element query(int id, int l, int r, const int &i, const int &j) {
    if (l > j || r < i) return {-1000000000000000007LL, -1};
    if (i <= l && r <= j) return t[id];
    int m = (l + r) / 2;
    return max(query(2 * id, l, m, i, j), query(2 * id + 1, m + 1, r, i, j));
  }

 public:
  void init(int n) {
    this->n = n;
    t.assign(4 * n + 1, {-1000000000000000007LL, -1});
  }
  void update(int p, Element e) { update(1, 1, n, p, e); }
  Element query(int i, int j) { return query(1, 1, n, i, j); }
};
int n, q, h[2 * 100005], s[2 * 100005];
long long d[2 * 100005], a[2 * 100005], b[2 * 100005];
IT t1, t2;
long long Solve(int l, int r) {
  Element maxA = t1.query(l, r);
  Element maxB = t2.query(l, r);
  long long res;
  if (maxA.ind == maxB.ind) {
    t1.update(maxA.ind, {-1000000000000000007LL, -1});
    t2.update(maxB.ind, {-1000000000000000007LL, -1});
    long long xA = t1.query(l, r).x;
    long long xB = t2.query(l, r).x;
    t1.update(maxA.ind, maxA);
    t2.update(maxB.ind, maxB);
    res = max(xA + maxB.x, xB + maxA.x);
  } else
    res = maxA.x + maxB.x;
  return res;
}
int main() {
  scanf("%d%d", &n, &q);
  for (int i = (1); i <= (n); ++i) scanf("%d", &s[i]);
  for (int i = (1); i <= (n); ++i) scanf("%d", &h[i]);
  for (int i = (1); i <= (2 * n); ++i) {
    if (i > n) {
      s[i] = s[i - n];
      h[i] = h[i - n];
    }
    d[i] = d[i - 1] + s[i];
    a[i] = 2 * h[i] + d[i - 1];
    b[i] = 2 * h[i] - d[i - 1];
  }
  t1.init(2 * n);
  t2.init(2 * n);
  for (int i = (1); i <= (2 * n); ++i) t1.update(i, {a[i], i});
  for (int i = (1); i <= (2 * n); ++i) t2.update(i, {b[i], i});
  for (int i = (1); i <= (q); ++i) {
    int l, r;
    scanf("%d%d", &l, &r);
    if (l <= r)
      printf("%lld\n", Solve(r + 1, l + n - 1));
    else
      printf("%lld\n", Solve(r + 1, l - 1));
  }
  return 0;
}
