#include <bits/stdc++.h>
using namespace std;
static constexpr int Maxn = 1e5 + 5, SqrN = 505;
int n, qn, bs, bn, bel[Maxn], bL[Maxn], bR[Maxn];
struct data_t {
  int64_t length, w;
  data_t() = default;
  data_t(int64_t length, int64_t w) : length(length), w(w) { }
  int64_t calc(int64_t len) const { return len * w; }
  friend bool operator < (const data_t &lhs, const data_t &rhs)
  { return pair(lhs.length, lhs.w) < pair(rhs.length, rhs.w); }
};
struct tag_t {
  vector<data_t> a, s;
  tag_t() = default;
  void insert(int64_t x, int64_t w) {
    int64_t px = a.empty() ? 0 : s.back().length;
    int64_t pw = a.empty() ? 0 : s.back().w;
    s.push_back(data_t(px + x, pw + x * w));
    a.push_back(data_t(x, w));
  }
  int64_t calc(int64_t len) const {
    if (s.empty()) return 0;
    if (len >= s.back().length) return s.back().w;
    auto it = lower_bound(s.begin(), s.end(), data_t(len, -1)) - s.begin();
    if (it == 0) return a[0].calc(len);
    else return a[it].calc(len - s[it - 1].length) + s[it - 1].w;
  }
  void erase(int64_t w) {
    while (!s.empty() && w) {
      if (a.back().length <= w)
        s.pop_back(), w -= a.back().length, a.pop_back();
      else {
        s.pop_back(); a.back().length -= w; w = 0;
        int px = s.empty() ? 0 : s.back().length;
        int64_t pw = s.empty() ? 0 : s.back().w;
        s.push_back(data_t(a.back().length + px, pw + a.back().calc(a.back().length)));
      }
    }
  }
  int length(void) const {
    return s.empty() ? 0 : s.back().length;
  }
  void clear(void) {
    a.clear(), s.clear();
  }
};
vector<tag_t> mem;
tag_t ta[Maxn];
int td[Maxn];
struct lazy {
  int64_t i, length, w;
  lazy() = default;
  lazy(int64_t i, int64_t len) : i(i), length(len) { }
  lazy(data_t d) : i(-1), length(d.length), w(d.w) { }
  int64_t calc(int64_t x) const {
    // fprintf(stderr, "--- i = %d, x = %d, length = %d\n", i, x, length);
    if (i != -1) return mem[i].calc(min(length, x));
    else return w * min(length, x);
  }
};
struct Stack {
  vector<lazy> a;
  vector<data_t> s;
  Stack() = default;
  void insert(int64_t x, int64_t w) {
    int64_t px = a.empty() ? 0 : s.back().length;
    int64_t pw = a.empty() ? 0 : s.back().w;
    a.push_back(lazy(data_t(x, w)));
    s.push_back(data_t(px + x, pw + a.back().calc(x)));
  }
  void insert_lazy(int64_t i, int64_t len) {
    int64_t px = a.empty() ? 0 : s.back().length;
    int64_t pw = a.empty() ? 0 : s.back().w;
    int64_t x = mem[i].length();
    a.push_back(lazy(i, len));
    s.push_back(data_t(px + x, pw + a.back().calc(x)));
  }
  void erase(int64_t w) {
    while (!a.empty() && w) {
      if (a.back().length <= w)
        s.pop_back(), w -= a.back().length, a.pop_back();
      else {
        s.pop_back(); a.back().length -= w; w = 0;
        int px = s.empty() ? 0 : s.back().length;
        int64_t pw = s.empty() ? 0 : s.back().w;
        s.push_back(data_t(a.back().length + px, pw + a.back().calc(a.back().length)));
      }
    }
  }
  int64_t calc(int64_t len) {
    if (s.empty() || len <= 0) return 0;
    if (len >= s.back().length) return s.back().w;
    auto it = lower_bound(s.begin(), s.end(), data_t(len, -1)) - s.begin();
    // fprintf(stderr, "len = %lld, it = %d\n", len, it);
    if (it == 0) return a[0].calc(len);
    else return a[it].calc(len - s[it - 1].length) + s[it - 1].w;
  }
} a[Maxn];
void pushtag(int b) {
  if (td[b] != 0) {
    for (int i = bL[b]; i <= bR[b]; ++i)
      a[i].erase(td[b]);
    td[b] = 0;
  }
  if (!ta[b].a.empty()) {
    mem.push_back(ta[b]);
    int j = mem.size() - 1;
    for (int i = bL[b]; i <= bR[b]; ++i) {
      // fprintf(stderr, "### i = %d, j = %d\n", i, j);
      a[i].insert_lazy(j, mem[j].length());
    }
    ta[b].clear();
  }
}
void add_tag(int b, int64_t len, int64_t w) {
  ta[b].insert(len, w);
} // add_tag
void del_tag(int b, int64_t len) {
  if (len >= ta[b].length()) td[b] += len - ta[b].length(), ta[b].clear();
  else ta[b].erase(len);
} // del_tag
int main(void) {
  cin.tie(nullptr)->sync_with_stdio(false);
  cin >> n >> qn; bs = (int)sqrt(n);
  // fprintf(stderr, "bs = %d\n", bs); fflush(stderr);
  for (int i = 1; i <= n; ++i)
    bel[i] = (i - 1) / bs + 1;
  bn = bel[n];
  for (int i = 1; i <= bn; ++i) {
    bL[i] = (i - 1) * bs + 1;
    bR[i] = min(i * bs, n);
  }
  while (qn--) {
    int op, l, r; cin >> op;
    if (op == 1) {
      cin >> l >> r;
      int64_t x, y; cin >> x >> y;
      if (bel[l] == bel[r]) {
        pushtag(bel[l]);
        for (int i = l; i <= r; ++i) a[i].insert(x, y);
      } else {
        pushtag(bel[l]), pushtag(bel[r]);
        for (int i = l; i <= bR[bel[l]]; ++i) a[i].insert(x, y);
        for (int i = bL[bel[r]]; i <= r; ++i) a[i].insert(x, y);
        for (int i = bel[l] + 1; i <= bel[r] - 1; ++i)
          add_tag(i, x, y);
      }
    } else if (op == 2) {
      int64_t w; cin >> l >> r >> w;
      if (bel[l] == bel[r]) {
        pushtag(bel[l]);
        for (int i = l; i <= r; ++i) a[i].erase(w);
      } else {
        pushtag(bel[l]), pushtag(bel[r]);
        for (int i = l; i <= bR[bel[l]]; ++i) a[i].erase(w);
        for (int i = bL[bel[r]]; i <= r; ++i) a[i].erase(w);
        for (int i = bel[l] + 1; i <= bel[r] - 1; ++i)
          del_tag(i, w);
      }
    } else if (op == 3) {
      int64_t k, p, q;
      cin >> k >> p >> q;
      pushtag(bel[k]);
      int64_t aq = a[k].calc(q), ap = a[k].calc(p - 1);
      // cerr << "aq = " << aq << ", ap = " << ap << endl;
      cout << aq - ap << endl;
    }
  }
  return 0;
} // main