// "I am the true mogger."
// 					-MihneaTheMogger
//
// prob Hotel
//
// tl 64 ms
// ml 64 MB
//
// LOT

#pragma GCC optimize("Ofast,Os,unroll-loops")

#include <bits/stdc++.h>
#define FastIO                         \
    ios_base::sync_with_stdio (false); \
    cin.tie (nullptr);                 \
    cout.tie (nullptr);
using namespace std;

#define int int64_t
#define YES cout << "YES"
#define YESn cout << "YES\n"
#define NO cout << "NO"
#define NOn cout << "NO\n"

#define MORE_TESTS 0
#define FASTIO 1
int32_t TESTCASE_COUNT = 1, TESTCASE;

class AINT
{
	struct lot {
		int st, dr, maxx;
	};
	size_t N;
	vector<lot> aint;
	vector<int> lazy;
	
	void push (int nod, int st, int dr) {
		if (lazy[nod] != -1) {
			if (lazy[nod]) {
				aint[nod] = {0, 0, 0};
				if (st != dr)
					lazy[nod * 2] = lazy[nod * 2 + 1] = 1;
			}
			else {
				aint[nod] = {dr - st + 1, dr - st + 1, dr - st + 1};
				if (st != dr)
					lazy[nod * 2] = lazy[nod * 2 + 1] = 0;
			}
		}
		lazy[nod] = -1;
	}
	
	void update (int nod, int l, int r, int lft, int rgt, int val) {
		push (nod, l, r);
		if (r < lft || rgt < l)
			return;
		if (lft <= l && r <= rgt) {
			lazy[nod] = val;
			push (nod, l, r);
		}
		else {
			int mid = (l + r) / 2;
			update (nod * 2, l, mid, lft, rgt, val);
			update (nod * 2 + 1, mid + 1, r, lft, rgt, val);
			if (aint[nod * 2].st == mid - l + 1) {
				aint[nod].st = aint[nod * 2].st + aint[nod * 2 + 1].st;
			}
			else {
				aint[nod].st = aint[nod * 2].st;
			}
			if (aint[nod * 2 + 1].st == r - mid) {
				aint[nod].dr = aint[nod * 2].dr + aint[nod * 2 + 1].dr;
			}
			else {
				aint[nod].dr = aint[nod * 2 + 1].dr;
			}
			aint[nod].maxx = max({aint[nod * 2].dr + aint[nod * 2 + 1].st, aint[nod * 2].maxx, aint[nod * 2 + 1].maxx});
		}
	}
	
public:
	AINT (size_t newsize, int val) {
		aint.resize(4 * (newsize + 1));
		lazy.resize(4 * (newsize + 1), -1);
		N = newsize;
		update (1, 1, N, 1, N, val);
	}
	
	void update (int st, int dr, int val) {
		return update (1, 1, N, st, dr, val);
	}
	
	int query () {
		return aint[1].maxx;
	}
};

void Solve () 
{
#ifndef LOCAL
	freopen("hotel.in", "r", stdin);
	freopen("hotel.out", "w", stdout);
#endif
	int n, q; cin >> n >> q;
	AINT aint (n, 0);
	for (; q; q --) {
		int op; cin >> op;
		int x, y;
		switch (op) {
			case 1:
				cin >> x >> y;
				aint.update (x, x + y - 1, 1);
				break;
			case 2:
				cin >> x >> y;
				aint.update (x, x + y - 1, 0);
				break;
			case 3:
				cout << aint.query () << '\n';
				break;
			default:
				break;
		}
	}
}

/*

*/

int32_t main () 
{
#if FASTIO == 1
    FastIO;
#endif
#if MORE_TESTS == 1
    cin >> TESTCASE_COUNT;
#endif
    for (TESTCASE = 1; TESTCASE <= TESTCASE_COUNT; TESTCASE++)
        Solve ();
}

/*
___  ___          _        ______         ___  ____ _                    _____ _         ___  ___
|  \/  |         | |       | ___ \        |  \/  (_) |                  |_   _| |        |  \/  |
| .  . | __ _  __| | ___   | |_/ /_   _   | .  . |_| |__  _ __   ___  __ _| | | |__   ___| .  . | ___   __ _  __ _  ___ _ __
| |\/| |/ _` |/ _` |/ _ \  | ___ \ | | |  | |\/| | | '_ \| '_ \ / _ \/ _` | | | '_ \ / _ \ |\/| |/ _ \ / _` |/ _` |/ _ \ '__|
| |  | | (_| | (_| |  __/  | |_/ / |_| |  | |  | | | | | | | | |  __/ (_| | | | | | |  __/ |  | | (_) | (_| | (_| |  __/ |
\_|  |_/\__,_|\__,_|\___|  \____/ \__, |  \_|  |_/_|_| |_|_| |_|\___|\__,_\_/ |_| |_|\___\_|  |_/\___/ \__, |\__, |\___|_|
                                   __/ |                                                                __/ | __/ |
                                  |___/                                                                |___/ |___/
*/