#include <bits/stdc++.h>

using namespace std;
ifstream in("hotel.in");
ofstream out("hotel.out");

const int NMAX = 100005;

struct AINT {
    int rmax, lmax; // subsecventa continua maxima care porneste din dreapta si stanga intervalului
    int maxlen; //subsecventa continua maxima
    int lazy; // 1 -> interval full   0 -> interval gol   -1 -> nu am lazy :)
}aint[4 * NMAX];

void cleannode(int node, int le, int ri) {
    if(aint[node].lazy == 0) {
        aint[node].rmax = aint[node].lmax = aint[node].maxlen = (ri - le + 1);
    }
    if(aint[node].lazy == 1) {
        aint[node].rmax = aint[node].lmax = aint[node].maxlen = 0;
    }

    if(le < ri && aint[node].lazy != -1) {
        aint[node * 2].lazy = aint[node].lazy;
        aint[node * 2 + 1].lazy = aint[node].lazy;
    }
    aint[node].lazy = -1;
}

void computenode(int node, int le, int ri) {
    if(le == ri)
        cleannode(node, le, ri);
    else {
        int mid = (le + ri) / 2;
        cleannode(2 * node, le, mid);
        cleannode(2 * node + 1, mid + 1, ri);

        aint[node].maxlen = max(aint[node * 2].rmax + aint[node * 2 + 1].lmax, max(aint[node * 2].maxlen, aint[node * 2 + 1].maxlen));

        aint[node].lmax = aint[node * 2].lmax;
        if(aint[node * 2].lmax == (mid - le + 1))
            aint[node].lmax += aint[node * 2 + 1].lmax;

        aint[node].rmax = aint[node * 2 + 1].rmax;
        if(aint[node * 2 + 1].rmax == (ri - mid))
            aint[node].rmax += aint[node * 2].rmax;
    }
}
void update(int from, int to, bool state, int node, int le, int ri) {
    if(from <= le && ri <= to) {
        aint[node].lazy = state;
        cleannode(node, le, ri);
    } else {
        cleannode(node, le, ri);
        int mid = (le + ri) / 2;
        if(from <= mid)
            update(from, to, state, node * 2, le, mid);
        if(mid < to)
            update(from, to, state, node * 2 + 1, mid + 1, ri);
        computenode(node, le, ri);
    }
}

void printtree(int node, int le, int ri) {
    cout << le << ", " << ri << " -> " << aint[node].lmax << " " << aint[node].maxlen << " " << aint[node].rmax  << " " << aint[node].lazy<< endl;
    if(le == ri)
        return;
    int mid = (le + ri) / 2;
            printtree(node * 2, le, mid);
            printtree(node * 2 + 1, mid + 1, ri);
}

void buildtree(int node, int le, int ri) {
    aint[node].rmax = aint[node].lmax = aint[node].maxlen = (ri - le + 1);
    aint[node].lazy = -1;
    if(le == ri)
        return;
    int mid = (le + ri) /2;
    buildtree(node * 2, le, mid);
    buildtree(node * 2 + 1, mid + 1, ri);
}

int main() {
    int n, p;
    in >> n >> p;
    buildtree(1, 1, n);
    for(int i = 1; i <= p; i ++) {
        int c, start, m;
        in >> c;
        if(c == 1) {
            in >> start >> m;
            update(start, start + m - 1, 1, 1, 1, n);
        }
        if(c == 2) {
            in >> start >> m;
            update(start, start + m - 1, 0, 1, 1, n);
        }
        if(c == 3)
            out << aint[1].maxlen << "\n";
    }

    return 0;
}