#include <bits/stdc++.h>
using i64 = long long;
const int N = 1e5, Q = 1e5;
int q;
struct Segment_Tree {
    static const int Q = ::Q * 4 + 5;
    struct Node { int l, r; std::array<i64, 3> s; }ar[Q + 5];
#define mid ((ar[k].l + ar[k].r) >> 1)
#define ls (k << 1)
#define rs (k << 1 | 1)
    void build(int l = 1, int r = q, int k = 1) {
        ar[k].l = l, ar[k].r = r;
        if (l < r) build(l, mid, ls), build(mid + 1, r, rs);
    }
    i64 ask(i64 x, int k = 1) {
        if (x <= 0) return 0;
        if (x >= ar[k].s[1]) return ar[k].s[2];
        if (ar[k].l == ar[k].r) return ar[k].s[1] ? ar[k].s[2] / ar[k].s[1] * x : 0;
        if (x <= ar[rs].s[1]) return ask(x, rs);
        x -= ar[rs].s[1];
        return ask(x + ar[rs].s[0], ls) - ask(ar[rs].s[0], ls) + ar[rs].s[2];
    }
    void pushup(int k) {
        if (ar[ls].s[1] > ar[rs].s[0]) {
            ar[k].s = ar[ls].s, ar[k].s[1] += ar[rs].s[1] - ar[rs].s[0];
            ar[k].s[2] += ar[rs].s[2] - ask(ar[rs].s[0], ls);
        }else ar[k].s = ar[rs].s, ar[k].s[0] += ar[ls].s[0] - ar[ls].s[1];
    }
    void update(int x, std::array<i64, 3> v, int k = 1) {
        if (x > ar[k].r or x < ar[k].l) return ;
        if (ar[k].l == ar[k].r) { ar[k].s = v; return ; }
        update(x, v, ls), update(x, v, rs), pushup(k);
    }
    std::array<i64, 2> queryc(int x, int k = 1) {
        if (x >= ar[k].r) return {ar[k].s[0], ar[k].s[1]};
        if (x <= mid) return queryc(x, ls);
        std::array<i64, 2> res = queryc(x, rs);
        if (ar[ls].s[1] < res[0]) return {res[0] - ar[ls].s[1] + ar[ls].s[0], res[1]};
        return {ar[ls].s[0], res[1] + ar[ls].s[1] - res[0]};
    }
    std::array<i64, 3> query(int x, i64 v, int k = 1) {
        if (v <= 0) return {0, 0, 0};
        if (x >= ar[k].r) {
            if (ar[k].s[1] < v) return ar[k].s;
            return {ar[k].s[0], v, ask(v, k)};
        }
        if (x <= mid) return query(x, v, ls);
        std::array<i64, 3> res = query(x, v, rs);
        if (ar[ls].s[1] - res[0] < v - res[1])
            return {res[0] + ar[ls].s[0], res[1] + ar[ls].s[1] - res[0], res[2] + ar[ls].s[2] - ask(res[0], ls)};
        return {res[0] + ar[ls].s[0], v, res[2] + ask(v - res[1] + res[0], ls) - ask(res[0], ls)};
    }
#undef mid
#undef ls
#undef rs
}tr;
struct Query { int op; i64 x, y; }qr[Q + 5];
i64 ans[Q + 5];
int n;
std::vector<std::array<int, 2>> upd[N + 5];
std::vector<int> qry[N + 5];
int main() {
    // freopen("stack.in", "r", stdin), freopen("stack.out", "w", stdout);
    std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    std::cin >> n >> q;
    for (int i = 1, l, r; i <= q; ++i) {
        std::cin >> qr[i].op;
        if (qr[i].op == 1) std::cin >> l >> r >> qr[i].x >> qr[i].y, upd[l].push_back({i, 1}), upd[r + 1].push_back({i, 0});
        else if (qr[i].op == 2) std::cin >> l >> r >> qr[i].x, upd[l].push_back({i, 1}), upd[r + 1].push_back({i, 0});
        else std::cin >> l >> qr[i].x >> qr[i].y, qry[l].push_back(i);
    }
    tr.build();
    for (int i = 1; i <= n; ++i) {
        for (auto [j, c] : upd[i]) {
            if (c) {
                if (qr[j].op == 1) tr.update(j, {0, qr[j].x, qr[j].x * qr[j].y});
                else tr.update(j, {qr[j].x, 0, 0});
            }else tr.update(j, {0, 0});
        }
        for (int j : qry[i]) {
            i64 cnt = tr.queryc(j)[1];
            ans[j] = tr.query(j, cnt - qr[j].x + 1)[2] - tr.query(j, cnt - qr[j].y)[2];
        }
    }
    for (int i = 1; i <= q; ++i) if (qr[i].op == 3) std::cout << ans[i] << "\n";
    return 0;
}