#include <bits/stdc++.h>
using namespace std;
template <typename T>
class MinArraySmall {
  vector<vector<T> > a;
  vector<vector<int> > b;
  vector<vector<T> > c;

 public:
  MinArraySmall(vector<T> one_layer) {
    a.push_back(one_layer);
    vector<int> indices;
    for (int i = 0; i < one_layer.size(); ++i) indices.push_back(i);
    b.push_back(indices);
    vector<T> second;
    for (int i = 0; i < one_layer.size(); ++i)
      second.push_back(1000000000000000ll);
    c.push_back(second);
    while (one_layer.size() > 1) {
      vector<T> next_layer;
      vector<int> next_indices;
      vector<T> next_second;
      for (int i = 0; i < (int)one_layer.size(); i += 2) {
        if (i + 1 < (int)one_layer.size()) {
          if (one_layer[i] < one_layer[i + 1]) {
            next_layer.push_back(one_layer[i]);
            next_indices.push_back(indices[i]);
            next_second.push_back(min(second[i], one_layer[i + 1]));
          } else {
            next_layer.push_back(one_layer[i + 1]);
            next_indices.push_back(indices[i + 1]);
            next_second.push_back(min(second[i + 1], one_layer[i]));
          }
        } else {
          next_layer.push_back(one_layer[i]);
          next_indices.push_back(indices[i]);
          next_second.push_back(second[i]);
        }
      }
      indices = next_indices;
      one_layer = next_layer;
      second = next_second;
      b.push_back(next_indices);
      c.push_back(next_second);
      a.push_back(next_layer);
    }
  }
  T getMin2(int left, int right, int& idx, T& scnd) {
    T rval = 0;
    int first = 1;
    scnd = 1000000000000000ll;
    while (left < right) {
      int size = 1;
      int level = 0;
      while (level < (int)a.size() && (left & size) == 0) {
        level++;
        size *= 2;
      }
      while (left + size > right) {
        level--;
        size /= 2;
      }
      int pt = left / size;
      T x = a[level][pt];
      if (first) {
        rval = x;
        scnd = c[level][pt];
        idx = b[level][pt];
        first = 0;
      } else {
        if (x <= rval) {
          scnd = rval;
          rval = x;
          idx = b[level][pt];
        } else {
          scnd = min(scnd, x);
        }
        scnd = min(scnd, c[level][pt]);
      }
      left += size;
    }
    return rval;
  }
  T getMin(int left, int right, int& idx) {
    T rval = a[0][left];
    idx = left;
    for (int i = left + 1; i < right; ++i) {
      if (rval >= a[0][i]) {
        rval = a[0][i];
        idx = i;
      }
    }
    return rval;
  }
};
int main() {
  int n, m;
  cin >> n >> m;
  vector<int> d(n), h(n);
  for (int i = 0; i < (int)(n); ++i) cin >> d[i];
  for (int i = 0; i < (int)(n); ++i) cin >> h[i];
  vector<long long int> for_min(n * 2), for_max;
  for (int i = 0; i < (int)(n); ++i)
    if (i) for_min[i] = for_min[i + n] = d[i - 1];
  for_min[n] = d[n - 1];
  for_min[0] = 0;
  for (int i = 0; i < (int)(n + n); ++i)
    if (i) for_min[i] += for_min[i - 1];
  for_max = for_min;
  for (int i = 0; i < (int)(n + n); ++i) for_min[i] -= h[i % n] * 2;
  for (int i = 0; i < (int)(n + n); ++i) for_max[i] += h[i % n] * 2;
  for (int i = 0; i < (int)(n + n); ++i) for_max[i] = -for_max[i];
  MinArraySmall<long long int> maxArray(for_max), minArray(for_min);
  for (int i = 0; i < (int)(m); ++i) {
    int left, right;
    cin >> left >> right;
    left--;
    right--;
    int l, r;
    if (left <= right) {
      l = right + 1;
      r = n + left;
    } else {
      l = right + 1;
      r = left;
    }
    int idx1;
    int idx2;
    long long int scnd1;
    long long int scnd2;
    long long int c1 = -maxArray.getMin2(l, r, idx1, scnd1);
    long long int c2 = minArray.getMin2(l, r, idx2, scnd2);
    scnd1 = -scnd1;
    long long int rval = 0;
    if (idx1 != idx2) {
      rval = c1 - c2;
    } else {
      rval = max(scnd1 - c2, c1 - scnd2);
    }
    cout << rval << endl;
  }
}
