#ifndef LOCAL_RUN
	#define NDEBUG
#endif
#ifdef GNU_DEBUG
	#define _GLIBCXX_DEBUG 1
	#define _GLIBCXX_DEBUG_PEDANTIC 1
	#define _GLIBCXX_SANITIZE_VECTOR 1
#endif
#include <bits/stdc++.h>
namespace {
#define mset(a, b) memset(&a, b, sizeof(a))
#define ALL(v) std::begin(v), std::end(v)
#define RANGE(a, l, r) (std::begin(a) + (l)), (std::begin(a) + ((r) + 1))
#define fir(i, a, b, ...) for (int i = (a), ##__VA_ARGS__; i <= (b); ++i)
#define firr(i, a, b, ...) for (int i = (a), ##__VA_ARGS__; i >= (b); --i)
#ifdef LOCAL_RUN
	template<class T> void dbgpr(const T& x) {std::cerr << x << std::endl;}
	template<class T, class... Args> void dbgpr(const T& x, const Args&... args) {std::cerr << x << ", ", dbgpr(args...);}
	template<class... Args> void dbgprint(const char* s, const Args&... args) {std::cerr << s << " = ", dbgpr(args...);}
	#define debug(...) dbgprint(#__VA_ARGS__, __VA_ARGS__)
	#define DEBUG if (true)
#else
	#define debug(...) void()
	#define DEBUG if (false)
#endif
typedef long long LL;
typedef long double LD;
typedef unsigned long long ULL;
template<class T> void rei(T& x) {
	bool f = false; int ch; x = 0;
	while (!isdigit(ch = getchar())) f = ch == '-';
	do x = x * 10 + (ch & 15); while (isdigit(ch = getchar()));
	if (f) x = -x;
}
template<class T1, class T2> bool cmax(T1& a, const T2& b) {return a < b ? a = b, true : false;}
template<class T1, class T2> bool cmin(T1& a, const T2& b) {return b < a ? a = b, true : false;}
using namespace std;

const int MAXN = 1e5 + 5;
const int SQTN = 1005;

int anstot, chgtot; const int B = 320;

struct Chg {int x, y; LL w;};
array<Chg, MAXN> chg;

int getid(int x) {return (x - 1) / B + 1;}
int getL(int p) {return (p - 1) * B + 1;}
int getR(int p) {return min(p * B, chgtot);}

array<LL, SQTN> del;
struct Node {int x, y; LL precnt, presum;};
array<vector<Node>, SQTN> stk;

array<LL, SQTN> siz;

void rebuild(int p) {
	int L = getL(p), R = getR(p);
	del[p] = 0, stk[p].clear();
	firr (i, R, L) {
		auto& c = chg[i];
		if (c.x) {
			if (c.x <= del[p]) del[p] -= c.x;
			else stk[p].push_back({int(c.x - del[p]), c.y, 0, 0}), del[p] = 0;
		} else {
			del[p] += c.w;
		}
	}
	reverse(ALL(stk[p]));
	LL cnt = 0, sum = 0;
	for (auto& it : stk[p]) {
		it.precnt = cnt += it.x;
		it.presum = sum += (LL)it.x * it.y;
	}
	fir (i, p, getid(chgtot)) {
		siz[i] = max(0LL, siz[i - 1] - del[i]);
		if (stk[p].size()) siz[i] += stk[p].back().precnt;
	}
}

LL query(int R, LL len) {
	static array<LL, MAXN> ss;
	int p = getid(R), fl = getL(p);
	ss[fl - 1] = siz[p - 1];
	fir (i, fl, R) {
		auto& c = chg[i];
		ss[i] = ss[i - 1];
		if (c.x) ss[i] += c.x;
		else ss[i] = max(0LL, ss[i] - c.w);
	}
	LL ban = 0, ans = 0;
	firr (i, R, getL(p)) {
		auto& c = chg[i];
		if (c.x) {
			if (c.x <= ban) ban -= c.x;
			else {
				LL pre = ss[i - 1];
				int cur = int(c.x - ban); ban = 0;
				if (pre <= len) {
					ans += min(len - pre, (LL)cur) * c.y;
				}
			}
		} else {
			ban += c.w;
		}
	}
	firr (i, p - 1, 1) {
		if (stk[i].size()) {
			if (stk[i].back().precnt <= ban) ban -= stk[i].back().precnt;
			else {
				LL pre = siz[i] - stk[i].back().precnt;
				if (pre <= len) {
					LL need = min(len - pre, stk[i].back().precnt - ban); assert(need >= 0);
					auto it = partition_point(ALL(stk[i]), [need](const Node& nd) {return nd.precnt <= need;});
					if (it != stk[i].begin()) ans += (it - 1)->presum, need -= (it - 1)->precnt, assert(need >= 0);
					if (it != stk[i].end()) ans += min(need, (LL)it->x) * it->y;
				}
				ban = 0;
			}
		}
		ban += del[i];
	}
	return ans;
}

struct Qry {int tim, op, x, y; LL w;};
array<vector<Qry>, MAXN> qry;
array<LL, MAXN> ans;

void solve(const Qry& q) {
	if (q.op < 0) {
		chg[q.tim] = {};
		rebuild(getid(q.tim));
		return;
	}
	if (q.op == 1) {
		chg[q.tim] = {q.x, q.y, 0};
		rebuild(getid(q.tim));
		return;
	}
	if (q.op == 2) {
		chg[q.tim] = {0, 0, q.w};
		rebuild(getid(q.tim));
		return;
	}
	LL res = query(q.tim, q.w);
	ans[q.x] += q.y * res;
}

void realmain() {
	DEBUG freopen("data.in", "r", stdin);
	int n, qwe; rei(n), rei(qwe);
	fir (i, 1, qwe) {
		int op; rei(op);
		if (op == 1) {
			chgtot++;
			int L, R, x, y; rei(L), rei(R), rei(x), rei(y);
			qry[L].push_back({chgtot, op, x, y, 0});
			qry[R + 1].push_back({chgtot, -op, 0, 0, 0});
		} else if (op == 2) {
			chgtot++;
			int L, R; LL w; rei(L), rei(R), rei(w);
			qry[L].push_back({chgtot, op, 0, 0, w});
			qry[R + 1].push_back({chgtot, -op, 0, 0, 0});
		} else {
			anstot++;
			int k; LL p, q; rei(k), rei(p), rei(q);
			qry[k].push_back({chgtot, op, anstot, 1, q});
			if (p > 1) qry[k].push_back({chgtot, op, anstot, -1, p - 1});
		}
	}
	fir (cur, 1, n) {
		for (auto& it : qry[cur]) {
			solve(it);
		}
	}
	fir (i, 1, anstot) printf("%lld\n", ans[i]);
}}
signed main(){return realmain(),0;}