// 2log

#include <bits/stdc++.h>

#if defined(LOCAL)
#define DBG_MACRO_NO_WARNING
#include <dbg.hpp>
#else
#define dbg(x...) (0)
#endif

using namespace std;

using ll = long long;

// #define int ll
#define rep(i, f, t) for (int i = (f), ed##i = (t); i <= ed##i; ++i)
#define re(i, t) rep (i, 1, t)
#define per(i, t, f) for (int i = (t), ed##i = (f); i >= ed##i; --i)
#define ste(i, f, t, s) for (int i = (f), ed##i = (t); i <= ed##i; i += s)
#define nxt(i, f, g) for (int i = g.h[f]; i; i = g.e[i].n)
#define umod(x) ((x) >= mo && ((x) -= mo))
#define dmod(x) ((x) < 0 && ((x) += mo))
#define y1 y1__
#define fio(x) (freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout))

template <class T, class E>
__attribute__((always_inline)) inline void up(T &x, E &&y) {
  if (x < y) x = y;
}
template <class T, class E>
__attribute__((always_inline)) inline void down(T &x, E &&y) {
  if (y < x) x = y;
}

const int N = 1e5 + 9;
const int RA = 4;
int n, m;

struct Tr {
  struct T {
    int ls, rs, sz;
    ll cnt, sum;
  } d[N * 20];
  int tot;

  inline void Up(int u) {
    d[u].sz = d[d[u].ls].sz + d[d[u].rs].sz;
    d[u].cnt = d[d[u].ls].cnt + d[d[u].rs].cnt;
    d[u].sum = d[d[u].ls].sum + d[d[u].rs].sum;
  }

  inline void Splk(ll &k, int &u, vector<int> &vl, vector<int> &vr) {
    assert(u);
    Adj(u);
    if (d[u].cnt <= k) return vl.push_back(u), k -= d[u].cnt, void();
    if (!k) return vr.push_back(u), void();
    if (!d[u].ls && !d[u].rs) {
      // cerr << "Splk corner case\n";
      ll val = d[u].sum / d[u].cnt;
      // dbg(val);
      int v1 = ++tot;
      d[v1].sz = 1, d[v1].cnt = k, d[v1].sum = val * d[v1].cnt;
      int v2 = ++tot;
      d[v2].sz = 1, d[v2].cnt = d[u].cnt - k, d[v2].sum = val * d[v2].cnt;
      // dbg(d[v1].cnt, d[v2].cnt);
      // dbg(d[v1].sum, d[v2].sum);
      k = 0;
      vl.push_back(v1), vr.push_back(v2);
      return;
    }
    Splk(k, d[u].ls, vl, vr);
    Splk(k, d[u].rs, vl, vr);
  }

  inline int Merge(int &u, int &v) {
    int sz = d[u].sz + d[v].sz;
    if (sz <= 5) {
      int rt = ++tot;
      d[rt].ls = u, d[rt].rs = v;
      Up(rt);
      return rt;
    }
    if (d[u].sz * RA < sz) {
      int ls = Merge(u, d[v].ls);
      int rt = ++tot;
      d[rt].ls = ls;
      d[rt].rs = d[v].rs;
      Up(rt);
      Adj(rt);
      return rt;
    }
    if (d[v].sz * RA < sz) {
      int rs = Merge(d[u].rs, v);
      int rt = ++tot;
      d[rt].ls = d[u].ls;
      d[rt].rs = rs;
      Up(rt);
      Adj(rt);
      return rt;
    }
    int rt = ++tot;
    d[rt].ls = u, d[rt].rs = v;
    Up(rt);
    Adj(rt);
    return rt;
  }

  inline int Mer(const vector<int> &vec, int l, int r) {
    if (l == r) return vec[l];
    int mid = (l + r) >> 1;
    int ls = Mer(vec, l, mid);
    int rs = Mer(vec, mid + 1, r);
    int u = Merge(ls, rs);
    Adj(u);
    return u;
  }

  inline void Adj(int &u) {
    if (d[u].sz <= 5) return;
    if (d[d[u].ls].sz * RA < d[d[u].rs].sz) {
      d[++tot] = d[u], u = tot;
      int rt = ++tot;
      d[rt] = d[d[u].rs];
      d[u].rs = d[rt].rs;
      d[rt].rs = d[rt].ls;
      d[rt].ls = d[u].ls;
      d[u].ls = rt;
      Up(rt);
      Up(u);
    } else if (d[d[u].rs].sz * RA < d[d[u].ls].sz) {
      d[++tot] = d[u], u = tot;
      int rt = ++tot;
      d[rt] = d[d[u].ls];
      d[u].ls = d[rt].ls;
      d[rt].ls = d[rt].rs;
      d[rt].rs = d[u].rs;
      d[u].rs = rt;
      Up(rt);
      Up(u);
    }
  }
} tr;

struct Dat {
  ll del;
  int rt;

  inline void Pop(ll x) {
    if (!rt) return del += x, void();
    if (tr.d[rt].cnt <= x)
      x -= tr.d[rt].cnt, rt = 0;
    else {
      vector<int> vl, vr;
      x = tr.d[rt].cnt - x;
      tr.Splk(x, rt, vl, vr);
      rt = tr.Mer(vl, 0, vl.size() - 1);
    }
    del += x;
  }

  inline ll Ask(ll l, ll r) {
    if (!rt) return 0;
    if (l > tr.d[rt].cnt) return 0;
    int rtbak = rt;
    down(r, tr.d[rt].cnt);
    ll len = r - l + 1;
    // dbg(len);
    --l;
    vector<int> v1, v2, v3, v4;
    tr.Splk(l, rt, v1, v4);
    for (auto u : v4) tr.Splk(len, u, v2, v3);
    ll ans = 0;
    for (auto u : v2) {
      ans += tr.d[u].sum;
      // dbg(tr.d[u].cnt);
    }
    rt = rtbak;
    return ans;
  }
};

inline Dat Mer(Dat x, Dat y) {
  x.Pop(y.del);
  if (!x.rt || !y.rt)
    x.rt |= y.rt;
  else {
    x.rt = tr.Merge(x.rt, y.rt);
  }
  return x;
}

struct Seg {
  Dat d[N << 2];

  inline void Pop(ll x, int u) { d[u].Pop(x); }

  inline void Push(int x, int y, int u) {
    int v = ++tr.tot;
    tr.d[v].sz = 1, tr.d[v].cnt = x, tr.d[v].sum = 1ll * x * y;
    if (!d[u].rt) {
      d[u].rt = v;
    } else {
      d[u].rt = tr.Merge(d[u].rt, v);
    }
  }

  inline void Down(int u) {
    d[u << 1] = Mer(d[u << 1], d[u]);
    d[u << 1 | 1] = Mer(d[u << 1 | 1], d[u]);
    d[u].del = 0, d[u].rt = 0;
  }

  inline void Pop(int L, int R, ll x, int u, int l, int r) {
    if (L <= l && r <= R) return Pop(x, u), void();
    int mid = (l + r) >> 1;
    Down(u);
    if (L <= mid) Pop(L, R, x, u << 1, l, mid);
    if (mid + 1 <= R) Pop(L, R, x, u << 1 | 1, mid + 1, r);
  }

  inline void Push(int L, int R, int x, int y, int u, int l, int r) {
    if (L <= l && r <= R) return Push(x, y, u), void();
    int mid = (l + r) >> 1;
    Down(u);
    if (L <= mid) Push(L, R, x, y, u << 1, l, mid);
    if (mid + 1 <= R) Push(L, R, x, y, u << 1 | 1, mid + 1, r);
  }

  inline ll Ask(int p, ll L, ll R, int u, int l, int r) {
    if (l == r) return d[u].Ask(L, R);
    int mid = (l + r) >> 1;
    Down(u);
    if (p <= mid) return Ask(p, L, R, u << 1, l, mid);
    return Ask(p, L, R, u << 1 | 1, mid + 1, r);
  }
} seg;

signed main() {
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  cin >> n >> m;
  while (m--) {
    int op;
    cin >> op;
    if (op == 1) {
      int l, r, x, y;
      cin >> l >> r >> x >> y;
      seg.Push(l, r, x, y, 1, 1, n);
    } else if (op == 2) {
      int l, r;
      ll x;
      cin >> l >> r >> x;
      seg.Pop(l, r, x, 1, 1, n);
    } else if (op == 3) {
      int p;
      ll l, r;
      cin >> p >> l >> r;
      cout << seg.Ask(p, l, r, 1, 1, n) << '\n';
    }
  }
  return 0;
}