#include <fstream>

using namespace std;

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

struct nod {
    int maxim, maxSt, maxDr, lazy;
} tree[400005];

void lazyUpdate(int nod, int st, int dr) {
    if(tree[nod].lazy == 1) {
        tree[nod].maxim = tree[nod].maxSt = tree[nod].maxDr = 0;
        if(st != dr) {
            tree[2 * nod].lazy = tree[2 * nod + 1].lazy = 1;
        }
    } else if(tree[nod].lazy == 2) {
        tree[nod].maxim = tree[nod].maxSt = tree[nod].maxDr = dr - st + 1;
        if(st != dr) {
            tree[2 * nod].lazy = tree[2 * nod + 1].lazy = 2;
        }
    }
    tree[nod].lazy = 0;
}

void nodeUpdate(int nod, int st, int dr) {
    int mid = (st + dr) / 2;
    if(tree[2 * nod].maxSt == mid - st + 1) {
        tree[nod].maxSt = mid - st + 1 + tree[2 * nod + 1].maxSt;
    } else {
        tree[nod].maxSt = tree[2 * nod].maxSt;
    }
    if(tree[2 * nod + 1].maxDr == dr - mid) {
        tree[nod].maxDr = dr - mid + tree[2 * nod].maxDr;
    } else {
        tree[nod].maxDr = tree[2 * nod + 1].maxDr;
    }
    tree[nod].maxim = max(tree[2 * nod].maxDr + tree[2 * nod + 1].maxSt, max(tree[2 * nod].maxim, tree[2 * nod + 1].maxim) );
}

void update(int nod, int st, int dr, int x, int y, int op) {
    if(st >= x && dr <= y) {
        tree[nod].lazy = op;
    } else {
        int mid = (st + dr) / 2;
        lazyUpdate(nod, st, dr);
        
        if(mid >= x) {
            update(2 * nod, st, mid, x, y, op);
        }
        if(mid < y) {
            update(2 * nod + 1, mid + 1, dr, x, y, op);
        }
        
        lazyUpdate(2 * nod, st, mid);
        lazyUpdate(2 * nod + 1, mid + 1, dr);
        
        nodeUpdate(nod, st, dr);
    }
}

int n, q, c;

int main() {
    fin >> n >> q;
    tree[1].lazy = 2;
    for(int t = 1; t <= q; t++) {
        fin >> c;
        if(c <= 2) {
            int st, cnt;
            fin >> st >> cnt;
            int dr = st + cnt - 1;
            update(1, 1, n, st, dr, c);
        } else {
            lazyUpdate(1, 1, n);
            fout << tree[1].maxim << "\n";
        }
    }
    return 0;
}