#include <bits/stdc++.h>
using namespace std;
#define L nod << 1
#define R L | 1
const int N = 100005;
struct lol{
    int l, st, dr, lazy;
} a[4*N];
int n, l, r, p, c;

void lazy_propagation(int nod, int st, int dr){
    if (!a[nod].lazy) return;
    if (a[nod].lazy == 1) a[nod] = {0, 0, 0, a[nod].lazy};
    else a[nod] = {dr-st+1, dr-st+1, dr-st+1, a[nod].lazy};
    if (st != dr) a[L].lazy = a[R].lazy = a[nod].lazy;
    a[nod].lazy = 0;
}

void update(int nod, int st, int dr){
    if (st >= l && dr <= r){
        a[nod].lazy = c;
        lazy_propagation(nod, st, dr);
        return;
    }
    lazy_propagation(nod, st, dr);
    int mid = (st + dr) >> 1;
    if (l <= mid) update(L, st, mid);
    else lazy_propagation(L, st, mid);
    if (r > mid) update(R, mid+1, dr);
    else lazy_propagation(R, mid + 1, dr);
    a[nod].l = max(a[L].dr + a[R].st, max(a[R].l, a[L].l));
    a[nod].st = a[L].st;
    if (a[nod].st == mid + 1 -st) a[nod].st += a[R].st;
    a[nod].dr = a[R].dr;
    if (a[nod].dr == dr - mid) a[nod].dr += a[L].dr;
}

int main(){
    ifstream cin ("hotel.in");
    ofstream cout ("hotel.out");
    cin >> n >> p;
    c = 2; l = 1; r = n;
    update(1, 1, n);
    while (p--){
        cin >> c;
        if (c == 3){
            lazy_propagation(1, 1, n);
            cout << a[1].l << "\n";
        }
        else{
            cin >> l >> r;
            r += l - 1;
            update(1, 1, n);
        }
    }
    return 0;
}