#include <iostream>
#include <cassert>
#include <queue>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <ctime>
#include <map>
#include <set>
using namespace std;
// #define int long long
#define pii pair<int, int>
#define eb emplace_back
#define F first
#define S second
#define test(x) cout << "Test: " << x << '\n'
#define lowbit(x) (x & -x)
#define debug puts("qwq");
#define open(x) freopen(#x".in", "r", stdin);freopen(#x".out", "w", stdout);
#define close fclose(stdin);fclose(stdout);
namespace FastIO {
	template <typename T = int>
	inline T read() {
		T s = 0, w = 1;
		char c = getchar();
		while (!isdigit(c)) {
			if (c == '-') w = -1;
			c = getchar();
		}
		while (isdigit(c)) s = (s << 1) + (s << 3) + (c ^ 48), c = getchar();
		return s * w;
	}
	template <typename T>
	inline void read(T &s) {
		s = 0;
		int w = 1;
		char c = getchar();
		while (!isdigit(c)) {
			if (c == '-') w = -1;
			c = getchar();
		}
		while (isdigit(c)) s = (s << 1) + (s << 3) + (c ^ 48), c = getchar();
		s = s * w;
	}
	template <typename T, typename... Arp> inline void read(T &x, Arp &...arp) {
		read(x), read(arp...);
	}
	template <typename T>
	inline void write(T x, char ch) {
		if (x < 0) x = -x, putchar('-');
		static char stk[25];
		int top = 0;
		do {
			stk[top++] = x % 10 + '0', x /= 10;
		} while (x);
		while (top) putchar(stk[--top]);
		putchar(ch);
		return;
	}
	template <typename T>
	inline void smax(T &x, T y) {
		if (x < y) x = y;
	}
	template <typename T>
	inline void smin(T &x, T y) {
		if (x > y) x = y;
	}
	void quit() {
		exit(0);
	}
} using namespace FastIO;
const int N = 2e5 + 19;
struct SegTree {
	#define ls (k << 1)
	#define rs (k << 1 | 1)
	#define mid ((l + r) >> 1)
	struct node {
		int lmax, rmax, sum, max;
	} t[N << 2];
	node merge(node x, node y) {
		return {max(x.lmax, x.sum + y.lmax), max(y.rmax, y.sum + x.rmax), x.sum + y.sum, max(max(x.max, y.max), x.rmax + y.lmax)};
	}
	int tag[N << 2], siz[N << 2];
	void build(int k, int l, int r) {
		siz[k] = r - l + 1;
		tag[k] = -1;
		if (l == r) return ;
		build(ls, l, mid); build(rs, mid+1, r);
	}
	void pushdown(int k) {
		if (~tag[k]) {
			t[ls] = {tag[k], tag[k], tag[k] * siz[ls], tag[k] * siz[ls]};
			t[rs] = {tag[k], tag[k], tag[k] * siz[rs], tag[k] * siz[rs]};
			tag[ls] = tag[rs] = tag[k];
			tag[k] = -1;
		}
	}
	void cover(int k, int l, int r, int L, int R, int s) {
		if (L <= l && r <= R) {
			tag[k] = s;
			t[k] = {s, s, s * (r - l + 1), s * (r - l + 1)};
			return ;
		}
		pushdown(k);
		if (L <= mid) cover(ls, l, mid, L, R, s);
		if (R > mid) cover(rs, mid+1, r, L, R, s);
		t[k] = merge(t[ls], t[rs]);
	}
	node query_max(int k, int l, int r, int L, int R) {
		if (L <= l && r <= R) return t[k];
		pushdown(k);
		if (L <= mid && R > mid) return merge(query_max(ls, l, mid, L, R), query_max(rs, mid+1, r, L, R));
		if (L <= mid) return query_max(ls, l, mid, L, R);
		return query_max(rs, mid+1, r, L, R);
	}
	int query_sum(int k, int l, int r, int L, int R) {
		if (L <= l && r <= R) return t[k].sum;
		pushdown(k);
		int ans = 0;
		if (L <= mid) ans += query_sum(ls, l, mid, L, R);
		if (R > mid) ans += query_sum(rs, mid+1, r, L, R);
		return ans;
	}
} seg;
signed main() {
	int n, q; read(n, q);
	seg.build(1, 1, n);
	while (q--) {
		int op, l, r, x, y;
		read(op, l, r);
		if (op == 0) {
			seg.cover(1, 1, n, l, r, 1);
		} else if (op == 1) {
			read(x, y);
			int cnt = (r - l + 1) - seg.query_sum(1, 1, n, l, r);
			seg.cover(1, 1, n, l, r, 1);
			int L = x, R = y;
			while (L < R) {
				int M = (L + R) >> 1;
				if (seg.query_sum(1, 1, n, x, M) < cnt) L = M + 1;
				else R = M;
			}
			seg.cover(1, 1, n, x, R, 0);
		} else {
			write(seg.query_max(1, 1, n, l, r).max, '\n');
		}
	}
	return 0;
}