#ifndef M_MODINT_H
#define M_MODINT_H

#include <bits/stdc++.h>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
#if __cplusplus < 201700L
#pragma GCC diagnostic ignored "-Wc++17-extensions"
#warning "Some features may not be available under c++17."
#endif

#define _static_helper __attribute__((always_inline)) constexpr inline static
#define _set_op(tp, op, attr)                                                  \
  attr tp operator op(const tp &rhs) const {                                   \
    tp lhs = *this;                                                            \
    return lhs op## = rhs;                                                     \
  }

// === BEGIN Modint library ===

namespace Moeebius {

template <uint32_t mod> class Modint {
  using i32 = std::int32_t;
  using u32 = std::uint32_t;
  using u64 = std::uint64_t;

  u32 _v;
  _static_helper u32 __get_inv_r(u32 x) {
    u32 y = x;
    y *= 2ull - x * y, y *= 2ull - x * y, y *= 2ull - x * y, y *= 2ull - x * y;
    return y;
  }
  _static_helper u32 __shrk(u32 x) { return std::min(x, x - mod); }
  _static_helper u32 __shrk2(u32 x) { return std::min(x, x - 2 * mod); }
  _static_helper u32 __dilt2(u32 x) { return std::min(x, x + 2 * mod); }
  _static_helper u32 __reduce(u64 x) {
    return (x + u64(u32(x) * -mod_inv) * mod) >> 32;
  }

  constexpr static inline u32 r2 = (1ull << 32) % mod * (1ull << 32) % mod,
                              mod_inv = __get_inv_r(mod);
  static_assert(mod && (mod < (1u << 30)) && (mod & 1) &&
                (mod_inv * mod) == 1u && __reduce(r2) == (1ull << 32) % mod);

public:
  constexpr Modint() : _v(0) {}
  constexpr Modint(u32 v) : _v(__reduce(u64(v) * r2)) {}
  constexpr Modint(i32 v) : _v(__reduce(u64(__dilt2(v % i32(mod))) * r2)) {}
  Modint operator-() const { return Modint() - *this; }
  constexpr Modint &operator+=(Modint rhs) {
    return _v = __shrk2(_v + rhs._v), *this;
  }
  constexpr Modint &operator-=(Modint rhs) {
    return _v = __dilt2(_v - rhs._v), *this;
  }
  constexpr Modint &operator*=(Modint rhs) {
    return _v = __reduce(u64(_v) * rhs._v), *this;
  }
  constexpr Modint pow(u64 y) const {
    Modint ans = 1, x = *this;
    while (y) {
      if (y & 1)
        ans *= x;
      x *= x, y >>= 1;
    }
    return ans;
  }
  constexpr Modint inv() const { return this->pow(mod - 2); }
  constexpr u32 val() const { return __shrk(__reduce(_v)); }
  constexpr Modint &operator/=(Modint rhs) { return (*this) *= rhs.inv(); }
  constexpr operator bool() const { return _v; }
  constexpr bool operator==(const Modint &rhs) const {
    return __shrk(_v) == __shrk(rhs._v);
  }
  constexpr bool operator!=(const Modint &rhs) const {
    return __shrk(_v) != __shrk(rhs._v);
  }
  _set_op(Modint, +, constexpr);
  _set_op(Modint, -, constexpr);
  _set_op(Modint, *, constexpr);
  _set_op(Modint, /, constexpr);
};

template <uint32_t mod>
std::istream &operator>>(std::istream &x, Modint<mod> &y) {
  int32_t _v;
  return x >> _v, y = _v, x;
}
template <uint32_t mod>
std::ostream &operator<<(std::ostream &x, Modint<mod> y) {
  return x << y.val();
}

} // namespace Moeebius

// === END Modint library ===

#undef _static_helper
#undef _set_op

#pragma GCC diagnostic pop

#endif

#include <bits/stdc++.h>

// #include <moeebius/modint.hpp>

using namespace std;

// #define LOCK_GETCHAR
// #define USE_INT_128

#if __cplusplus < 201400
#warning "Please use c++14 or higher."
#define CONSTEXPR_FUNC
#else
#define CONSTEXPR_FUNC constexpr
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define _loop_i_t(j, k) make_signed_t<decltype((j) - (k))>
#define For(i, j, k) for (_loop_i_t(j, k) i = (j); i <= (k); ++i) // NOLINT
#define ForDown(i, j, k)                                                       \
  for (_loop_i_t(j, k) i = (j); i >= decltype(i)(k); --i) // NOLINT
#define eb emplace_back
#ifndef ONLINE_JUDGE
#define FileIO(filename)                                                       \
  freopen(filename ".in", "r", stdin);                                         \
  freopen(filename ".out", "w", stdout)
#else
#define FileIO(filename) void(0)
#endif

using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#ifdef USE_INT_128
using lll = __int128_t;
using ulll = __uint128_t;
#endif

// clang-format off
CONSTEXPR_FUNC il ll qpow(ll x, ull y, ll mod){ ll ans = 1; x %= mod; while (y) { if (y & 1) (ans *= x) %= mod; (x *= x) %= mod; y >>= 1; } return ans; }
template<typename T> CONSTEXPR_FUNC il void cmin(T & x, const T &y){ x = min(x, y); }
template<typename T> CONSTEXPR_FUNC il void cmax(T & x, const T &y){ x = max(x, y); }
// clang-format on

namespace FastIO {
// ------------------------------
// #define DISABLE_MMAP
// ------------------------------
#if (defined(LOCAL) || defined(_WIN32) || defined(__APPLE__)) &&               \
    !defined(DISABLE_MMAP)
#define DISABLE_MMAP
#endif
#ifdef LOCAL
inline char gc() { return getchar(); }
inline void pc(char c) { putchar(c); }
#else
#ifdef DISABLE_MMAP
inline constexpr int _READ_SIZE = 1 << 18;
inline static char _read_buffer[_READ_SIZE], *_read_ptr = nullptr,
                                             *_read_ptr_end = nullptr;
inline char gc() {
  if (__builtin_expect(_read_ptr == _read_ptr_end, false)) {
    _read_ptr = _read_buffer,
    _read_ptr_end = _read_buffer + fread(_read_buffer, 1, _READ_SIZE, stdin);
    if (__builtin_expect(_read_ptr == _read_ptr_end, false))
      return EOF;
  }
  return *_read_ptr++;
}
#else
#include <sys/mman.h>
inline static const char *_read_ptr =
    (const char *)mmap(nullptr, 0x7fffffff, 1, 2, 0, 0);
inline char gc() { return *_read_ptr++; }
#endif
inline constexpr int _WRITE_SIZE = 1 << 18;
inline static char _write_buffer[_WRITE_SIZE], *_write_ptr = _write_buffer;
inline void pc(char c) {
  *_write_ptr++ = c;
  if (__builtin_expect(_write_buffer + _WRITE_SIZE == _write_ptr, false))
    fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout),
        _write_ptr = _write_buffer;
}
inline struct _auto_flush {
  inline ~_auto_flush() {
    fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout);
  }
} _auto_flush;
#endif
template <class T>
inline constexpr bool _is_signed = numeric_limits<T>::is_signed;
template <class T>
inline constexpr bool _is_unsigned =
    numeric_limits<T>::is_integer && !_is_signed<T>;
#if __SIZEOF_LONG__ == 64
template <> inline constexpr bool _is_signed<__int128> = true;
template <> inline constexpr bool _is_unsigned<__uint128_t> = true;
#endif
inline void read(char &c) {
  do
    c = gc();
  while (!isgraph(c));
}
inline void read_cstr(char *s) {
  char c = gc();
  while (!isgraph(c))
    c = gc();
  while (isgraph(c))
    *s++ = c, c = gc();
  *s = 0;
}
inline void read(string &s) {
  char c = gc();
  s.clear();
  while (!isgraph(c))
    c = gc();
  while (isgraph(c))
    s.push_back(c), c = gc();
}
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void read(T &x) {
  char c = gc();
  bool f = true;
  x = 0;
  while (!isdigit(c)) {
    if (c == 45)
      f = false;
    c = gc();
  }
  if (f)
    while (isdigit(c))
      x = x * 10 + (c & 15), c = gc();
  else
    while (isdigit(c))
      x = x * 10 - (c & 15), c = gc();
}
template <class T, enable_if_t<_is_unsigned<T>, int> = 0>
inline void read(T &x) {
  char c = gc();
  while (!isdigit(c))
    c = gc();
  x = 0;
  while (isdigit(c))
    x = x * 10 + (c & 15), c = gc();
}
inline void write(char c) { pc(c); }
inline void write_cstr(const char *s) {
  while (*s)
    pc(*s++);
}
inline void write(const string &s) {
  for (char c : s)
    pc(c);
}
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void write(T x) {
  char buffer[numeric_limits<T>::digits10 + 1];
  int digits = 0;
  if (x >= 0)
    do
      buffer[digits++] = (x % 10) | 48, x /= 10;
    while (x);
  else {
    pc(45);
    do
      buffer[digits++] = -(x % 10) | 48, x /= 10;
    while (x);
  }
  while (digits)
    pc(buffer[--digits]);
}
template <class T, enable_if_t<_is_unsigned<T>, int> = 0>
inline void write(T x) {
  char buffer[numeric_limits<T>::digits10];
  int digits = 0;
  do
    buffer[digits++] = (x % 10) | 48, x /= 10;
  while (x);
  while (digits)
    pc(buffer[--digits]);
}
template <int N> struct _tuple_io_helper {
  template <class... T> static inline void _read(tuple<T...> &x) {
    _tuple_io_helper<N - 1>::_read(x), read(get<N - 1>(x));
  }
  template <class... T> static inline void _write(const tuple<T...> &x) {
    _tuple_io_helper<N - 1>::_write(x), pc(32), write(get<N - 1>(x));
  }
};
template <> struct _tuple_io_helper<1> {
  template <class... T> static inline void _read(tuple<T...> &x) {
    read(get<0>(x));
  }
  template <class... T> static inline void _write(const tuple<T...> &x) {
    write(get<0>(x));
  }
};
template <class... T> inline void read(tuple<T...> &x) {
  _tuple_io_helper<sizeof...(T)>::_read(x);
}
template <class... T> inline void write(const tuple<T...> &x) {
  _tuple_io_helper<sizeof...(T)>::_write(x);
}
template <class T1, class T2> inline void read(pair<T1, T2> &x) {
  read(x.first), read(x.second);
}
template <class T1, class T2> inline void write(const pair<T1, T2> &x) {
  write(x.first), pc(32), write(x.second);
}
template <class T1, class... T2> inline void read(T1 &x, T2 &...y) {
  read(x), read(y...);
}
template <class... T> inline void read_cstr(char *x, T *...y) {
  read_cstr(x), read_cstr(y...);
}
template <class T1, class... T2>
inline void write(const T1 &x, const T2 &...y) {
  write(x), write(y...);
}
template <class... T> inline void write_cstr(const char *x, const T *...y) {
  write_cstr(x), write_cstr(y...);
}
} // namespace FastIO

using FastIO::read;
using FastIO::read_cstr;
using FastIO::write;
using FastIO::write_cstr;

// File head end

namespace {
constexpr int MAXN = 2e5 + 5, B1 = 180, B2 = 512, mod = 1e9 + 7;
using Z = Moeebius::Modint<mod>;
template <int N> struct Arr2D {
  array<Z, (N * (N + 1) / 2) + 1> _val;
  Z &at(int x, int y) { // i mod x = y
    return _val[x * (x - 1) / 2 + y];
  }
};
int n, m;
Z a[MAXN], sum[B2];
Arr2D<B1> pre, suf;

il Z qry(int l, int r) {
  int u = l / B2, v = r / B2;
  Z ans{};
  if (abs(v - u) <= 2) {
    For(i, l, r) ans += a[i];
    return ans;
  }
  For(i, l, (u + 1) * B2 - 1) ans += a[i];
  For(i, u + 1, v - 1) ans += sum[i];
  For(i, v * B2, r) ans += a[i];
  return ans;
}

il void Main() {
  read(n, m);
  For(i, 0, n - 1) {
    int x;
    read(x), a[i] = x, sum[i / B2] += x;
  }
  while (m--) {
    int op, x, y, z;
    read(op, x, y);
    if (op == 1) {
      read(z), y--;
      Z zz = z;
      if (x <= B1) {
        For(i, y, x - 1) pre.at(x, i) += zz;
        For(i, 0, y) suf.at(x, i) += zz;
      } else {
        for (int i = y; i < n; i += x)
          a[i] += zz, sum[i / B2] += zz;
      }
    } else {
      x--, y--;
      Z ans = qry(x, y);
      For(i, 1, B1) {
        int v1 = x % i, v2 = y % i, len = y / i - x / i - 1;
        ans += suf.at(i, 0) * Z(len);
        ans += pre.at(i, v2) + suf.at(i, v1);
      }
      write(ans.val(), '\n');
    }
  }
}
} // namespace

signed main() { return Main(), 0; }