#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define s set<N>
#define _ emplace
#define da erase
#define E end()
#define B begin()

ifstream fin("hotel.in");
ofstream fout("hotel.out");

void maxSelf(int &x, int y) {
	if(y > x) {
		x = y;
	}
}

void minSelf(int &x, int y) {
	if(y < x) {
		x = y;
	}
}

struct _cc_ {
	struct N {
		int l, r;
		mutable int v;
		N() {}
		N(int l, int r = -1, int v = 0): l(l), r(r), v(v) {}
		bool operator < (const N &oth) const {
			return l < oth.l;
		}
	};

	int n;
	s __;
	_cc_() {}
	_cc_(int n): n(n) {
		__._(0, n - 1);
	}
	_cc_(int n, const vector<int> &v): n(n) {
		init(v);
	}
	void init(const vector<int> &v) {
		for(int i = 0; i < n; i++) {
			__._(i, i, v[i]);
		}
		__._(n, n, 0);
	}
	set<N>::iterator SS(int x) {
		auto it = __.lower_bound(N(x));
		if(it != __.E && it->l == x) {
			return it;
		}
		// assert(it != __.B);
		it = prev(it);
		if(it->r < x) {
			return __.E;
		}
		int l = it->l, r = it-> r, v = it->v;
		__.da(it);
		__._(l, x - 1, v);
		return __._(x, r, v).first;
	}
	void F(int l, int r, int v) {
		auto R = SS(r + 1), L = SS(l);
		__.da(L, R);
		__._(l, r, v);
	}
	int QSQ() {
		int sum = 0, res = 0;
		for(const auto &it: __) {
			if(it.v == 0) {
				sum += it.r - it.l + 1;
			} else {
				sum = 0;
			}
			maxSelf(res, sum);
		}
		return res;
	}
};

int main() {
	int n, p;
	fin >> n >> p;
	_cc_ ds(n);
	for(int i = 0; i < p; i++) {
		int op, l, r;
		fin >> op;

		if(op == 3) {
			fout << ds.QSQ() << '\n';
		} else {
			int l, r;
			fin >> l >> r;
			r += l - 1;
			l--; r--;

			if(op == 1) {
				ds.F(l, r, 1);
			} else {
				ds.F(l, r, 0);
			}
		}
	}
	return 0;
}