#include <bits/stdc++.h>

#define int int64_t

const int kMaxN = 2e5 + 5;

int n, m, rt, sgt_cnt;
int a[kMaxN], b[kMaxN], c[kMaxN], ans[kMaxN];
int lg[kMaxN], sta[kMaxN][20], stb[kMaxN][20];
int ls[kMaxN * 60], rs[kMaxN * 60], sum[kMaxN * 60], tag[kMaxN * 60];
std::vector<std::tuple<int, int, int>> qq[kMaxN];

int get(int x, int y) {
  return b[x] < b[y] ? x : y;
}

void st_prework() {
  lg[0] = -1;
  for (int i = 1; i <= n + 1; ++i) {
    sta[i][0] = a[i];
    stb[i][0] = i;
    lg[i] = lg[i >> 1] + 1;
  }
  for (int i = 1; i <= lg[n + 1]; ++i) {
    for (int j = 1; j <= n + 1 - (1 << i) + 1; ++j) {
      sta[j][i] = std::max(sta[j][i - 1], sta[j + (1 << (i - 1))][i - 1]);
      stb[j][i] = get(stb[j][i - 1], stb[j + (1 << (i - 1))][i - 1]);
    }
  }
}

int querya(int l, int r) {
  int k = lg[r - l + 1];
  return std::max(sta[l][k], sta[r - (1 << k) + 1][k]);
}

int queryb(int l, int r) {
  int k = lg[r - l + 1];
  return get(stb[l][k], stb[r - (1 << k) + 1][k]);
}

void prework() {
  st_prework();
}

void update(int &x, int l, int r, int ql, int qr, int v) {
  if (l > qr || r < ql) return;
  if (!x) x = ++sgt_cnt;
  sum[x] += 1ll * v * (std::min(r, qr) - std::max(l, ql) + 1);
  if (l >= ql && r <= qr) return void(tag[x] += v);
  int mid = (l + r) >> 1;
  update(ls[x], l, mid, ql, qr, v), update(rs[x], mid + 1, r, ql, qr, v);
}

int query(int x, int l, int r, int ql, int qr) {
  if (!x || l > qr || r < ql) return 0;
  else if (l >= ql && r <= qr) return sum[x];
  int mid = (l + r) >> 1;
  return query(ls[x], l, mid, ql, qr) + query(rs[x], mid + 1, r, ql, qr) + 1ll * tag[x] * (std::min(r, qr) - std::max(l, ql) + 1);
}

int res[kMaxN];

void upd(int l, int r, int k, int b, int v) {
  l = std::max<int>(l, 0), r = std::min<int>(r, 1e8);
  if (l > r || !k && !b) return;
  // std::cerr << l << ' ' << r << ' ' << k << ' ' << b << ' ' << v << '\n';
  update(rt, 0, 1e8, l, l, (k * l + b) * v);
  update(rt, 0, 1e8, l + 1, r, k * v);
  update(rt, 0, 1e8, r + 1, r + 1, -(k * r + b) * v);
  // for (int i = l; i <= r; ++i) res[i] += v * (k * i + b);
}

void work(int x, int pre, int nxt, int v) {
  assert(x > pre && x < nxt);
  std::vector<int> vec = {0, c[nxt] - c[x]};
  if (pre) vec.emplace_back(c[nxt] - c[pre]), vec.emplace_back(c[x] - c[pre]);
  else vec.emplace_back(1e8 + 1);
  std::sort(vec.begin(), vec.end());
  vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
  for (int i = 0; i + 1 < (int)vec.size(); ++i) {
    int l = vec[i], r = vec[i + 1] - 1, k = 0, b = 0;
    if (c[x] + l <= c[nxt] && c[x] + r <= c[nxt]) ++k, b += c[x];
    else b += c[nxt];
    if (c[x] >= c[pre] + l && c[x] >= c[pre] + r) b -= c[x];
    else --k, b -= c[pre];
    upd(l, r, k, b, v * ::b[x]);
  }
  // for (int u = 0; u <= 1e3; ++u) {
  //   if (std::max(c[i], c[pre] + u) < std::min(c[i] + u, c[nxt]))
  //     res[u] += v * b[i] * (std::min(c[i] + u, c[nxt]) - std::max(c[i], c[pre] + u));
  // }
}

void getans() {
  static int top, stk[kMaxN], nxt[kMaxN];
  stk[top = 1] = n + 1;
  c[0] = -1e9;
  for (int i = n; i; --i) {
    for (; top && b[stk[top]] >= b[i]; --top) {
      work(stk[top], 0, nxt[stk[top]], -1);
      work(stk[top], i, nxt[stk[top]], 1);
    }
    nxt[i] = stk[top];
    stk[++top] = i;
    work(i, 0, nxt[i], 1);
    for (auto [id, u, v] : qq[i]) ans[id] += v * query(rt, 0, 1e8, 0, u);
    // for (auto [id, u, v] : qq[i]) ans[id] += v * res[u];
  }
}

void dickdreamer() {
  std::cin >> n >> m;
  for (int i = 1; i <= n; ++i) {
    std::cin >> a[i];
    c[i + 1] = c[i] + a[i];
  }
  for (int i = 1; i <= n; ++i)
    std::cin >> b[i];
  prework();
  for (int i = 1; i <= m; ++i) {
    int s, t, u;
    std::cin >> s >> t >> u;
    if (querya(s, t - 1) > u) {
      ans[i] = -1;
      continue;
    }
    int p = std::max(s, std::upper_bound(c + 1, c + 2 + n, c[t] - u) - c), k = queryb(p, t);
    ans[i] = b[k] * (c[t] - c[k]);
    qq[s].emplace_back(i, u, 1), qq[k].emplace_back(i, u, -1);
  }
  getans();
  for (int i = 1; i <= m; ++i) std::cout << ans[i] << '\n';
}

int32_t main() {
#ifdef ORZXKR
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  int T = 1;
  // std::cin >> T;
  while (T--) dickdreamer();
  // std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  return 0;
}