#include <iostream>
#include <fstream>

#define NMAX 100003

using namespace std;

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

struct Node {
    int smax, pref_smax, suff_smax, lazy;
}tree[4 * NMAX];

int N, M;

void update_node(int nod, int le, int ri) {
    int mid = (le + ri) / 2;
    int le_son = 2 * nod;
    int ri_son = 2 * nod + 1;

    tree[nod].pref_smax = (tree[le_son].pref_smax == (mid - le + 1) ?
                          (mid - le + 1) + tree[ri_son].pref_smax :
                           tree[le_son].pref_smax);

    tree[nod].suff_smax = (tree[ri_son].suff_smax == (ri - mid) ?
                           (ri - mid) + tree[le_son].suff_smax :
                           tree[ri_son].suff_smax);

    tree[nod].smax = max(tree[le_son].suff_smax + tree[ri_son].pref_smax, max(tree[ri_son].smax, tree[le_son].smax));
}

void update_lazy(int nod, int le, int ri) {
    if (!tree[nod].lazy)
        return;

    int val = 0;
    if (tree[nod].lazy == 2)
        val = ri - le + 1;

    tree[nod].smax = val;
    tree[nod].pref_smax = val;
    tree[nod].suff_smax = val;

    if (le != ri) {
        tree[2 * nod].lazy = tree[nod].lazy;
        tree[2 * nod + 1].lazy = tree[nod].lazy;
    }

    tree[nod].lazy = 0;

//    if (tree[nod].lazy == 1) {
//        tree[nod].smax = 0;
//        tree[nod].pref_smax = 0;
//        tree[nod].suff_smax = 0;
//
//        if (le != ri) {
//            tree[2 * nod].lazy = 1;
//            tree[2 * nod + 1].lazy = 1;
//        }
//
//        tree[nod].lazy = 0;
//
//    } else if (tree[nod].lazy == 2) {
//        tree[nod].smax = ri - le + 1;
//        tree[nod].suff_smax = ri - le + 1;
//        tree[nod].pref_smax = ri - le + 1;
//
//        if (le != ri) {
//            tree[2 * nod].lazy = 2;
//            tree[2 * nod + 1].lazy = 2;
//        }
//
//        tree[nod].lazy = 0;
//    }
}


void update(int nod, int le, int ri, int x, int y, int state) {

    if (x <= le && ri <= y) {
        tree[nod].lazy = state;
        return;
    }


    update_lazy(nod, le, ri);

    int mid = (le + ri) / 2;
    if (x <= mid)
        update(2 * nod, le, mid, x, y, state);
    if (y >= mid + 1)
        update(2 * nod + 1, mid + 1, ri, x, y, state);

    update_lazy(2 * nod, le, mid);
    update_lazy(2 * nod + 1, mid + 1, ri);

    update_node(nod, le, ri);
}

int main() {

    fin >> N >> M;

    tree[1].lazy = 2;
    for (int q = 0; q < M; q++) {
        int p;
        fin >> p;
        if (p <= 2) {
            int x, l;
            fin >> x >> l;

            int y = x + l - 1;
            update(1, 1, N, x, y, p);
        } else {
            update_lazy(1, 1, N);
            fout << tree[1].smax << '\n';
        }
    }


    return 0;
}