//#include "pch.h"
#include <iostream>
#include <fstream>
#include <algorithm>

using namespace std;

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

static const int  NMAX = 100005;

int aint[4 * NMAX];
int lazy[4 * NMAX];
int startLength[4 * NMAX];
int endLength[4 * NMAX];

void propagate(int node, int left, int right, int middle) {
	if (node > 4 * NMAX) {
		return;
	}

	if (!lazy[node]) {
		return;
	}

	if (4 * node + 1 < 4 * NMAX) {
		lazy[2 * node] = lazy[node];
		lazy[2 * node + 1] = lazy[node];

		if (!aint[node]) {
			aint[2 * node] = 0;
			aint[2 * node + 1] = 0;

			startLength[2 * node] = startLength[2*node+1] = 0;
			endLength[2 * node] = endLength[2 * node + 1] = 0;
		}
		else {
			aint[2 * node] = middle - left + 1;
			aint[2 * node + 1] = right - middle;

			startLength[2 * node] = endLength[2*node] = middle - left + 1;
			startLength[2 * node + 1] = endLength[2 * node + 1] = right - middle;
		}
	}

	lazy[node] = 0;
}

void update(int node, int left, int right, int a, int b, int value) {

	if (left >= a && right <= b) {
		lazy[node] = value;
		
		if (lazy[node] == -1) {
			startLength[node] = right - left + 1;
			endLength[node] = right - left + 1;
			aint[node] = right - left + 1;
		} 

		if (lazy[node] == 1) {
			startLength[node] = 0;
			endLength[node] = 0;
			aint[node] = 0;
		}

		return;
	}

	int middle = left + (right - left) / 2;

	propagate(node, left, right, middle);

	if (middle >= a) {
		update(2 * node, left, middle, a, b, value);
	}

	if (middle < b) {
		update(2 * node + 1, middle + 1, right, a, b, value);
	}

	startLength[node] = startLength[2 * node] == middle - left + 1 ? startLength[2 * node] + startLength[2 * node + 1] : startLength[2 * node];
	endLength[node] = endLength[2 * node + 1] == right - middle ? endLength[2 * node] + endLength[2 * node + 1] : endLength[2 * node + 1];

	aint[node] = max(aint[2 * node], aint[2 * node + 1]);
	aint[node] = max(aint[node], max(startLength[node], endLength[node]));
	aint[node] = max(aint[node], startLength[2 * node + 1] + endLength[2 * node]);
}

int main() {
	ios::sync_with_stdio(false);
	fin.tie(0); fout.tie(0);

	int n, p;
	fin >> n >> p;
	
	for (int i = 1; i <= 4 * n; ++i) {
		lazy[i] = -1;
	}

	update(1, 1, n, 1, n, -1);

	for (int i = 1; i <= p; ++i) {
		int type, l, k, r;
		fin >> type;

		switch (type) {
		case 1:
			fin >> l >> k;
			r = l + k - 1;
			update(1, 1, n, l, r, 1);
			break;
		case 2:
			fin >> l >> k;
			r = l + k - 1;
			update(1, 1, n, l, r, -1);
			break;
		case 3:
			fout << aint[1] << '\n';
			break;
		}
	}
}