#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(T x) {
  return x * x;
}
const double EPS = 1e-9;
const long long INF = (long long)1e17;
struct Node {
  long long sum_d;
  long long pref;
  long long suff;
  long long ans;
  int l, r;
  Node() {}
};
struct SegmTree {
  vector<Node> t;
  int sz;
  vector<long long> d;
  vector<long long> h;
  Node jslkdjflkdslkf(Node a, Node b) {
    Node c;
    c.l = a.l;
    c.r = b.r;
    long long D = 0 <= a.r && a.r < ((int)(d).size()) ? d[a.r] : -INF;
    c.pref = max(a.pref, a.sum_d + D + b.pref);
    c.suff = max(b.suff, a.suff + D + b.sum_d);
    c.sum_d = a.sum_d + D + b.sum_d;
    c.ans = max(b.ans, max(a.ans, a.suff + D + b.pref));
    return c;
  }
  SegmTree() {}
  SegmTree(vector<long long> d_, vector<long long> h_) {
    d = d_;
    h = h_;
    sz = 1;
    while (sz < ((int)(d).size())) sz *= 2;
    while (((int)(d).size()) < sz) d.push_back(-INF);
    while (((int)(h).size()) < sz) h.push_back(-INF);
    t.resize(2 * sz);
    init(1, 0, sz - 1);
  }
  void init(int v, int tl, int tr) {
    if (tl == tr) {
      t[v].pref = 2ll * h[tl];
      t[v].suff = 2ll * h[tl];
      t[v].ans = -INF;
      t[v].l = tl;
      t[v].r = tl;
      t[v].sum_d = 0;
      return;
    }
    int tm = (tl + tr) / 2;
    init(v * 2, tl, tm);
    init(v * 2 + 1, tm + 1, tr);
    t[v] = jslkdjflkdslkf(t[v * 2], t[v * 2 + 1]);
  }
  Node get(int v, int tl, int tr, int l, int r) {
    l = max(l, tl);
    r = min(r, tr);
    if (tl == l && tr == r) {
      return t[v];
    }
    if (2 * v >= ((int)(t).size())) {
      while (1) {
      }
    }
    int tm = (tl + tr) / 2;
    if (r <= tm) {
      return get(v * 2, tl, tm, l, r);
    }
    if (tm < l) {
      return get(v * 2 + 1, tm + 1, tr, l, r);
    }
    return jslkdjflkdslkf(get(v * 2, tl, tm, l, tm),
                          get(v * 2 + 1, tm + 1, tr, tm + 1, r));
  }
  long long get(int l, int r) {
    if (!(0 <= l && l <= r && r < sz)) {
      return -INF;
    }
    return get(1, 0, sz - 1, l, r).ans;
  }
};
SegmTree T;
vector<long long> h;
vector<long long> d;
int n, m;
int main() {
  scanf("%d%d", &n, &m);
  d.resize(2 * n);
  for (int i = 0; i < (int)n; ++i) {
    scanf("%I64d", &d[i]);
    d[i + n] = d[i];
  }
  h.resize(2 * n);
  for (int i = 0; i < (int)n; ++i) {
    scanf("%I64d", &h[i]);
    h[i + n] = h[i];
  }
  T = SegmTree(d, h);
  for (int i = 0; i < (int)m; ++i) {
    int l, r;
    scanf("%d%d", &l, &r);
    --l;
    --r;
    long long ans = -INF;
    if (l <= r) {
      int l1 = l;
      int r1 = r;
      int l2 = l1 + n;
      int r2 = r1 + n;
      ans = max(T.get(0, l1 - 1), T.get(r1 + 1, l2 - 1));
      ans = max(ans, T.get(r2 + 1, 2 * n - 1));
    } else {
      ans = T.get(r + 1, l - 1);
    }
    printf("%I64d\n", ans);
  }
  return 0;
}
