#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
template<class T = int> using V  = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<class T> void assign(V<T>& v, int n, const T& a = T()) { v.assign(n, a); }
template<class T, class... Args> void assign(V<T>& v, int n, const Args&... args) { v.resize(n); for (auto&& e : v) assign(e, args...); }


constexpr lint mod = 1e9 + 7;
inline lint emod(lint a, lint p = mod) { return (a % p + p) % p; }

struct Monoid {
  using T = struct { lint v, fib; };
  static T op(const T& lhs, const T& rhs) { return {(lhs.v + rhs.v) % mod, (lhs.fib + rhs.fib) % mod}; }
  static constexpr T e() { return {0, 0}; }
};

template<class Monoid> struct MonoidAct {
  using T = struct { lint a, b, c; };
  static void ap(const T& f, typename Monoid::T& a, int len) { a.v = (f.a * a.v + f.b * len + f.c * a.fib) % mod; }
  static void cp(const T& f, T& g) { (g.a *= f.a) %= mod, g.b = (f.a * g.b + f.b) % mod, g.c = (f.a * g.c + f.c) % mod; }
  static constexpr T id() { return {1, 0, 0}; }
};
bool operator!=(const MonoidAct<Monoid>::T& lhs, const MonoidAct<Monoid>::T& rhs) { return lhs.a != rhs.a or lhs.b != rhs.b or lhs.c != rhs.c; }

template<class Monoid, class MonoidAct> struct SegmentTree {
  using Tv = typename Monoid::T;
  using Ta = typename MonoidAct::T;
  struct Node {
    lint l, r, m, len;
    Tv val;
    Ta act;
    unique_ptr<Node> cl, cr;
    Node(lint l, lint r) : l(l), r(r), m(l + r >> 1), len(r - l),val(Monoid::e()), act(MonoidAct::id()) {}
  };

  lint n;
  unique_ptr<Node> root;

  SegmentTree(lint n) : n(n), root(make_unique<Node>(0, n)) {}

  Tv get(lint l, lint r) { return _get(l, r, root); }

  void set(lint l, lint r, const Ta& f) { _set(l, r, f, root); }

  void set(lint i, const Tv& a) { _set(i, a, root); }

  Tv _get(lint l, lint r, const unique_ptr<Node>& v) {
    if (l <= v->l and v->r <= r) return v->val;
    if (v->act != MonoidAct::id()) _push(v);
    Tv resl = Monoid::e(), resr = Monoid::e();
    if (l < v->m) {
      if (v->cl == nullptr) v->cl = make_unique<Node>(v->l, v->m);
      resl = _get(l, r, v->cl);
    }
    if (v->m < r) {
      if (v->cr == nullptr) v->cr = make_unique<Node>(v->m, v->r);
      resr = _get(l, r, v->cr);
    }
    return Monoid::op(resl, resr);
  }

  void _push(const unique_ptr<Node>& v) {
    if (v->cl == nullptr) v->cl = make_unique<Node>(v->l, v->m);
    MonoidAct::ap(v->act, v->cl->val, v->cl->len);
    MonoidAct::cp(v->act, v->cl->act);
    if (v->cr == nullptr) v->cr = make_unique<Node>(v->m, v->r);
    MonoidAct::ap(v->act, v->cr->val, v->cr->len);
    MonoidAct::cp(v->act, v->cr->act);
    v->act = MonoidAct::id();
  }

  void _set(lint l, lint r, const Ta& f, const unique_ptr<Node>& v) {
    if (l <= v->l and v->r <= r) {
      MonoidAct::ap(f, v->val, v->len);
      MonoidAct::cp(f, v->act);
      return;
    }
    if (v->act != MonoidAct::id()) _push(v);
    if (l < v->m) {
      if (v->cl == nullptr) v->cl = make_unique<Node>(v->l, v->m);
      _set(l, r, f, v->cl);
    }
    if (v->m < r) {
      if (v->cr == nullptr) v->cr = make_unique<Node>(v->m, v->r);
      _set(l, r, f, v->cr);
    }
    v->val = Monoid::op(v->cl != nullptr ? v->cl->val : Monoid::e(), v->cr != nullptr ? v->cr->val : Monoid::e());
  }

  void _set(lint i, const Tv& a, const unique_ptr<Node>& v) {
    if (v->len == 1) {
      v->val = a;
      return;
    }
    if (v->act != MonoidAct::id()) _push(v);
    if (i < v->m) {
      if (v->cl == nullptr) v->cl = make_unique<Node>(v->l, v->m);
      _set(i, a, v->cl);
    } else {
      if (v->cr == nullptr) v->cr = make_unique<Node>(v->m, v->r);
      _set(i, a, v->cr);
    }
    v->val = Monoid::op(v->cl != nullptr ? v->cl->val : Monoid::e(), v->cr != nullptr ? v->cr->val : Monoid::e());
  }
};

int main() {
  cin.tie(nullptr); ios::sync_with_stdio(false);
  int n, Q; cin >> n >> Q;
  V<Monoid::T> v(n);
  v[1].fib = 1;
  for (int i = 2; i < n; ++i) v[i].fib = (v[i - 1].fib + v[i - 2].fib) % mod;
  SegmentTree< Monoid, MonoidAct<Monoid> > st(n);
  for (int i = 0; i < n; ++i) st.set(i, v[i]);
  for (int i = 0; i < Q; ++i) {
    int q, l, r, k; cin >> q >> l >> r >> k, ++r;
    switch (q) {
      case 0: cout << emod(k * st.get(l, r).v) << '\n'; break;
      case 1: st.set(l, r, {0, k, 0}); break;
      case 2: st.set(l, r, {1, k, 0}); break;
      case 3: st.set(l, r, {k, 0, 0}); break;
      case 4: st.set(l, r, {1, 0, k}); break;
    }
  }
}