#include <bits/stdc++.h>
using namespace std;
struct Node {
  int leftmost;
  int size;
  int left_child;
  int right_child;
  long long sum;
  long long left_sum;
  long long right_sum;
  long long internal_sum;
};
static Node nodes[200200];
static int dists[100100];
static int free_node;
inline void calc(int node, int left, int right) {
  Node &n = nodes[node];
  Node &l = nodes[left];
  Node &r = nodes[right];
  if (l.size == 0) {
    n = r;
    return;
  }
  if (r.size == 0) {
    n = l;
    return;
  }
  n.leftmost = l.size ? l.leftmost : r.leftmost;
  n.size = l.size + r.size;
  n.left_child = left;
  n.right_child = right;
  int const between = dists[l.leftmost + l.size - 1];
  n.sum = l.sum + between + r.sum;
  long long const whole_left = l.sum + between + r.left_sum;
  if (whole_left > l.left_sum) {
    n.left_sum = whole_left;
  } else {
    n.left_sum = l.left_sum;
  }
  long long const whole_right = l.right_sum + between + r.sum;
  if (whole_right > r.right_sum) {
    n.right_sum = whole_right;
  } else {
    n.right_sum = r.right_sum;
  }
  long long const cross_internal = l.right_sum + between + r.left_sum;
  n.internal_sum = max(max(l.internal_sum, r.internal_sum), cross_internal);
}
inline pair<int, int> split(int node, int left_size) {
  if (nodes[node].size == 0) {
    return make_pair(0, 0);
  }
  Node &n = nodes[node];
  if (left_size == n.size) {
    return make_pair(node, 0);
  }
  if (left_size == 0) {
    return make_pair(0, node);
  }
  Node &l = nodes[n.left_child];
  Node &r = nodes[n.right_child];
  if (left_size <= l.size) {
    pair<int, int> const parts = split(n.left_child, left_size);
    int const right = free_node++;
    calc(right, parts.second, n.right_child);
    return make_pair(parts.first, right);
  } else {
    pair<int, int> const parts = split(n.right_child, left_size - l.size);
    int const left = free_node++;
    calc(left, n.left_child, parts.first);
    return make_pair(left, parts.second);
  }
}
int main() {
  int n = 0;
  int m = 0;
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &dists[i]);
  }
  for (int i = 1; i <= n; ++i) {
    int height = 0;
    scanf("%d", &height);
    Node &n = nodes[i];
    n.leftmost = i;
    n.size = 1;
    n.left_sum = 2 * height;
    n.right_sum = 2 * height;
    n.internal_sum = numeric_limits<int>::min();
  }
  free_node = n + 1;
  int prev = 1;
  int level_size = n;
  do {
    level_size = (level_size + 1) / 2;
    int next = free_node + 1;
    for (int i = 0; i < level_size; ++i) {
      calc(++free_node, prev, prev + 1);
      prev += 2;
    }
    prev = next;
    ++free_node;
  } while (level_size > 1);
  int const root = free_node - 1;
  for (int i = 0; i < m; ++i) {
    int const old_free = free_node;
    int a = 0;
    int b = 0;
    scanf("%d%d", &a, &b);
    if (a <= b) {
      pair<int, int> const parts = split(root, a - 1);
      int const left = split(parts.second, b - a + 1).second;
      int const new_root = free_node;
      calc(new_root, left, parts.first);
      printf("%I64d\n", nodes[new_root].internal_sum);
    } else {
      pair<int, int> const parts = split(root, b);
      Node &new_root = nodes[split(parts.second, a - b - 1).first];
      printf("%I64d\n", new_root.internal_sum);
    }
    free_node = old_free;
  }
}
