#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
  if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
  return *(pinbuf++);
}
inline void _putchar(char x) {
  if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
  *(poutbuf++) = x;
}
inline void flush() {
  if (poutbuf != outbuf)
    fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
}  // namespace IO
inline int read() {
  int x = 0, p = 1;
  char c = getchar();
  while (c <= 32) c = getchar();
  if (c == 45) p = -p, c = getchar();
  while (c > 32) x = x * 10 + c - 48, c = getchar();
  return x * p;
}
namespace Mymath {
long long qp(long long x, long long p, long long mod) {
  long long ans = 1;
  while (p) {
    if (p & 1) ans = ans * x % mod;
    x = x * x % mod;
    p >>= 1;
  }
  return ans;
}
long long inv(long long x, long long mod) { return qp(x, mod - 2, mod); }
long long C(long long N, long long K, long long fact[], long long mod) {
  return fact[N] * inv(fact[K], mod) % mod * inv(fact[N - K], mod) % mod;
}
template <typename Tp>
Tp gcd(Tp A, Tp B) {
  if (B == 0) return A;
  return gcd(B, A % B);
}
template <typename Tp>
Tp lcm(Tp A, Tp B) {
  return A * B / gcd(A, B);
}
};  // namespace Mymath
namespace fwt {
using namespace Mymath;
void FWT(int a[], int n, long long mod) {
  for (int d = 1; d < n; d <<= 1)
    for (int m = d << 1, i = 0; i < n; i += m)
      for (int j = 0; j < d; j++) {
        int x = a[i + j], y = a[i + j + d];
        a[i + j] = (x + y) % mod, a[i + j + d] = (x - y + mod) % mod;
      }
}
void UFWT(int a[], int n, long long mod) {
  long long rev = inv(2, mod);
  for (int d = 1; d < n; d <<= 1)
    for (int m = d << 1, i = 0; i < n; i += m)
      for (int j = 0; j < d; j++) {
        int x = a[i + j], y = a[i + j + d];
        a[i + j] = 1LL * (x + y) * rev % mod,
              a[i + j + d] = (1LL * (x - y) * rev % mod + mod) % mod;
      }
}
void solve(int a[], int b[], int n, long long mod) {
  FWT(a, n, mod);
  FWT(b, n, mod);
  for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * b[i] % mod;
  UFWT(a, n, mod);
}
};  // namespace fwt
namespace Maxflow {
const int Maxn = 1005;
struct edge {
  int to, rev, cap;
  edge(int _to, int _rev, int _cap) { to = _to, rev = _rev, cap = _cap; }
};
int src = 1002, snk = 1003;
vector<edge> G[Maxn];
int dist[Maxn], seen[Maxn];
int n;
void Clear() {
  for (int i = 0; i < Maxn; i++) G[i].clear();
}
void bfs(int s) {
  for (int i = 0; i < Maxn; i++) dist[i] = -1;
  dist[s] = 0;
  queue<int> Q;
  Q.push(s);
  while (!Q.empty()) {
    int x = Q.front();
    Q.pop();
    for (int i = 0; i < G[x].size(); i++) {
      edge &e = G[x][i];
      if (e.cap && dist[e.to] == -1) {
        dist[e.to] = dist[x] + 1;
        Q.push(e.to);
      }
    }
  }
}
int dfs(int now, int dest, int fl) {
  if (now == dest) return fl;
  for (int &i = seen[now]; i < G[now].size(); i++) {
    edge &ed = G[now][i];
    if (ed.cap && dist[ed.to] == dist[now] + 1) {
      int f = dfs(ed.to, dest, min(fl, ed.cap));
      if (f) {
        ed.cap -= f;
        G[ed.to][ed.rev].cap += f;
        return f;
      }
    }
  }
  return 0;
}
int dinic(int s = src, int t = snk) {
  int ret = 0;
  while (1) {
    memset(seen, 0, sizeof(seen));
    bfs(s);
    if (dist[t] == -1) return ret;
    int f = dfs(s, t, 2147483647);
    while (f) {
      ret += f;
      f = dfs(s, t, 2147483647);
    }
  }
}
};  // namespace Maxflow
namespace Geometry {
struct iP {
  long long x, y;
  iP(long long _x, long long _y) { x = _x, y = _y; }
  iP() { x = y = 0; }
  iP operator+(iP p) { return iP(x + p.x, y + p.y); }
  iP operator-(iP p) { return iP(x - p.x, y - p.y); }
  iP operator*(long long k) { return iP(x * k, y * k); }
  long long det(iP p) { return x * p.y - y * p.x; }
  long long dot(iP p) { return x * p.x + y * p.y; }
  long long dist() { return x * x + y * y; }
  bool operator<(const iP &p) const {
    if (x != p.x) return x < p.x;
    return y < p.y;
  }
};
struct dP {
  double x, y;
  dP(double _x, double _y) { x = _x, y = _y; }
  dP() { x = y = 0.0; }
  dP operator+(dP p) { return dP(x + p.x, y + p.y); }
  dP operator-(dP p) { return dP(x - p.x, y - p.y); }
  dP operator*(double k) { return dP(x * k, y * k); }
  double det(dP p) { return x * p.y - y * p.x; }
  double dot(dP p) { return x * p.x + y * p.y; }
  double dist() { return x * x + y * y; }
  bool operator<(const dP &p) const {
    if (x != p.x) return x < p.x;
    return y < p.y;
  }
};
vector<iP> convex_hull(iP X[], int l) {
  vector<iP> ret;
  sort(X + 1, X + 1 + l);
  ret.push_back(X[1]);
  for (int i = 2; i <= l; i++) {
    while (ret.size() >= 2 &&
           (ret[ret.size() - 2] - X[i]).det(ret[ret.size() - 1] - X[i]) >= 0) {
      ret.pop_back();
    }
    ret.push_back(X[i]);
  }
  int rs = ret.size() + 1;
  for (int i = l - 1; i >= 1; i--) {
    while (ret.size() >= rs &&
           (ret[ret.size() - 2] - X[i]).det(ret[ret.size() - 1] - X[i]) >= 0) {
      ret.pop_back();
    }
    ret.push_back(X[i]);
  }
  return ret;
}
};  // namespace Geometry
const int Maxn = 200005;
const long long mod = 1e9 + 7;
int n, q;
long long a[Maxn], w[Maxn];
long long t1[Maxn];
long long t2[Maxn];
long long t3[Maxn];
void A1(int p, long long v) {
  v = (v % mod + mod) % mod;
  while (p < Maxn) {
    t1[p] += v;
    if (t1[p] >= mod) t1[p] -= mod;
    p += p & -p;
  }
}
void A3(int p, long long v) {
  v = (v % mod + mod) % mod;
  while (p < Maxn) {
    t3[p] += v;
    if (t3[p] >= mod) t3[p] -= mod;
    p += p & -p;
  }
}
void A2(int p, long long v) {
  while (p < Maxn) {
    t2[p] += v;
    if (t2[p] >= mod) t2[p] -= mod;
    p += p & -p;
  }
}
long long Q1(int p) {
  long long ret = 0;
  while (p) {
    ret += t1[p];
    p -= p & -p;
  }
  return ret % mod;
}
long long Q3(int p) {
  long long ret = 0;
  while (p) {
    ret += t3[p];
    p -= p & -p;
  }
  return ret % mod;
}
long long Q2(int p) {
  long long ret = 0;
  while (p) {
    ret += t2[p];
    p -= p & -p;
  }
  return ret;
}
int main() {
  scanf("%d %d", &n, &q);
  for (int i = 1; i <= n; i++) {
    scanf("%I64d", &a[i]);
  }
  for (int i = 1; i <= n; i++) {
    scanf("%I64d", &w[i]);
  }
  for (int i = 1; i <= n; i++) {
    A1(i, a[i] * w[i] % mod);
    A2(i, w[i]);
    A3(i, w[i] * i);
  }
  while (q--) {
    int x, y;
    scanf("%d %d", &x, &y);
    if (x < 0) {
      x = -x;
      long long dlt = y - w[x];
      A1(x, a[x] * dlt);
      A2(x, dlt);
      A3(x, 1ll * x * dlt);
      w[x] += dlt;
    } else {
      int l = x, r = y;
      long long S = Q2(r) - Q2(l - 1);
      int lo = l, hi = r;
      long long bf = Q2(l - 1);
      while (hi - lo > 1) {
        int mid = lo + hi >> 1;
        if ((Q2(mid) - bf) * 2 <= S) {
          lo = mid;
        } else {
          hi = mid;
        }
      }
      int pos = a[hi];
      long long Sl = Q2(hi) - Q2(l - 1);
      Sl = (Sl % mod + mod) % mod;
      long long WS = Sl;
      Sl = Sl * pos % mod;
      Sl -= Q1(hi) - Q1(l - 1);
      Sl = (Sl % mod + mod) % mod;
      long long ffuck = WS * hi;
      long long fuck = Q3(hi) - Q3(l - 1);
      fuck = ffuck - fuck;
      fuck = (fuck % mod + mod) % mod;
      Sl -= fuck;
      if (Sl < 0) Sl += mod;
      long long Sr = Q2(r) - Q2(hi);
      Sr = (Sr % mod + mod) % mod;
      WS = Sr;
      Sr = Sr * pos % mod;
      Sr = (Q1(r) - Q1(hi)) - Sr;
      Sr = (Sr % mod + mod) % mod;
      ffuck = WS * hi;
      fuck = Q3(r) - Q3(hi);
      fuck = fuck - ffuck;
      fuck = (fuck % mod + mod) % mod;
      Sr -= fuck;
      if (Sr < 0) Sr += mod;
      Sl = Sl + Sr;
      Sl %= mod;
      printf("%I64d\n", Sl);
    }
  }
  return ~~(0 ^ 0 ^ 0);
}
