#include <stdio.h>
#include <string.h>

#include <random>
#include <chrono>
#include <algorithm>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long LL;
constexpr int N = 400005, TC = 20000005;

char gc() {
	static char buf[1 << 21], *p1 = buf, *p2 = buf;
	return (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? -1 : *p1++);
}
LL read() {
	LL x = 0; char c = gc();
	while (c < 48 || c > 57) c = gc();
	for (; c > 47 && c < 58; c = gc()) x = x * 10 + (c ^ 48);
	return x;
}

mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());

int n;

#define L (tr[z].l)
#define R (tr[z].r)

struct Tree {
	int l, r, h, v, c;
	LL s, sz;
} tr[TC];
int ids;

void upd(int z) {
	tr[z].sz = tr[L].sz + tr[R].sz + tr[z].c;
	tr[z].s = tr[L].s + tr[R].s + tr[z].v * (LL)tr[z].c;
}

int gd(int c, int v) {
	int z = ++ids;
	tr[z].h = (int)rnd();
	tr[z].v = v, tr[z].c = tr[z].sz = c;
	tr[z].s = v * (LL)c;
	return z;
}

int merge(int x, int y) {
	if (!x || !y) {
		return x | y;
	}
	int z = ++ids;
	if (tr[x].h < tr[y].h) {
		tr[z] = tr[x];
		tr[z].r = merge(tr[z].r, y);
		upd(z);
		return z;
	}
	tr[z] = tr[y];
	tr[z].l = merge(x, tr[z].l);
	upd(z);
	return z;
}

void splitC(int z, LL c, int &x, int &y) {
	if (!z) {
		x = y = 0;
		return;
	}
	if (tr[L].sz >= c) {
		y = ++ids, tr[y] = tr[z];
		splitC(tr[z].l, c, x, tr[y].l);
		upd(y);
	} else if (tr[L].sz + tr[z].c <= c) {
		x = ++ids, tr[x] = tr[z];
		splitC(tr[z].r, c - tr[L].sz - tr[z].c, tr[x].r, y);
		upd(x);
	} else {
		x = gd(c - tr[L].sz, tr[z].v);
		tr[x].l = tr[z].l;
		upd(x);
		y = gd(tr[z].c + tr[L].sz - c, tr[z].v);
		tr[y].r = tr[z].r;
		upd(y);
	}
}

LL qry(int z, LL ql, LL qr) {
	if (qr < 1 || ql > tr[z].sz) {
		return 0ll;
	}
	if (ql <= 1 && qr >= tr[z].sz) {
		return tr[z].s;
	}
	LL ret = 0;
	if (ql <= tr[L].sz + tr[z].c && tr[L].sz < qr) {
		ret += (min(qr, tr[L].sz + tr[z].c) - max(ql - 1, tr[L].sz)) * tr[z].v;
	}
	return qry(L, ql, qr) + ret + qry(R, ql - tr[L].sz - tr[z].c, qr - tr[L].sz - tr[z].c);
}

#undef L
#undef R

#define L (z << 1)
#define R (z << 1 | 1)

int rt[4 * N];
LL rem[4 * N];

void tagA(int z, int t) {
	rt[z] = merge(rt[z], t);
}

void tagRem(int z, LL c) {
	int &r = rt[z], ers;
	if (c <= tr[r].sz) {
		splitC(r, tr[r].sz - c, r, ers);
	} else {
		rem[z] += c - tr[r].sz;
		r = 0;
	}
}

void Down(int z) {
	LL &s = rem[z];
	if (s) {
		tagRem(L, s), tagRem(R, s);
		s = 0;
	}
	int &r = rt[z];
	if (r) {
		tagA(L, r), tagA(R, r);
		r = 0;
	}
}

void Exy(int ql, int qr, int t, int l = 1, int r = n, int z = 1) {
	if (l >= ql && r <= qr) {
		tagA(z, t);
	} else {
		int mid = l + r >> 1;
		Down(z);
		if (ql <= mid) {
			Exy(ql, qr, t, l, mid, L);
		}
		if (mid < qr) {
			Exy(ql, qr, t, mid + 1, r, R);
		}
	}
}

void Ers(int ql, int qr, LL cnt, int l = 1, int r = n, int z = 1) {
	if (l >= ql && r <= qr) {
		tagRem(z, cnt);
	} else {
		int mid = l + r >> 1;
		Down(z);
		if (ql <= mid) {
			Ers(ql, qr, cnt, l, mid, L);
		}
		if (mid < qr) {
			Ers(ql, qr, cnt, mid + 1, r, R);
		}
	}
}

LL Query(int x, LL xl, LL xr, int l = 1, int r = n, int z = 1) {
	if (l == r) {
		return qry(rt[z], xl, xr);
	}
	int mid = l + r >> 1;
	Down(z);
	if (x <= mid) {
		return Query(x, xl, xr, l, mid, L);
	}
	return Query(x, xl, xr, mid + 1, r, R);
}

int main() {
	// LOG("%.3lf\n", (sizeof tr + sizeof rt * 3) / 1048576.0);
	int m;
	n = read(), m = read();
	int t; LL x, y, z, w;
	while (m--) {
		t = read(), x = read(), y = read(), z = read();
		if (t == 1) {
			w = read();
			Exy(x, y, gd(z, w));
		} else if (t == 2) {
			Ers(x, y, z);
		} else {
			printf("%lld\n", Query(x, y, z));
		}
	}
	return 0;
}