#include <bits/stdc++.h>

using namespace std;

const int nmax = 100005;
int n, test, lazy_add[nmax*4], lazy_rem[nmax*4], aintl[nmax*4], aintr[nmax*4], aint[nmax*4];

void propagate(int nod, int st, int dr)
{
    if(lazy_add[nod]){
        aintl[nod] = 0;
        aintr[nod] = 0;
        aint[nod] = 0;
        lazy_add[nod] = 0;
        lazy_rem[nod] = 0;
        if(st != dr){
            lazy_add[nod*2] = 1;
            lazy_add[nod*2+1] = 1;
            lazy_rem[nod*2] = 0;
            lazy_rem[nod*2+1] = 0;
        }
    }
    if(lazy_rem[nod]){
        aintl[nod] = dr-st+1;
        aintr[nod] = dr-st+1;
        aint[nod] = dr-st+1;
        lazy_rem[nod] = 0;
        lazy_add[nod] = 0;
        if(st != dr){
            lazy_rem[nod*2] = 1;
            lazy_rem[nod*2+1] = 1;
            lazy_add[nod*2] = 0;
            lazy_add[nod*2+1] = 0;
        }
    }
}

void update_add(int nod, int st, int dr, int l, int r)
{
    if(lazy_rem[nod]){
        aintl[nod] = dr-st+1;
        aintr[nod] = dr-st+1;
        aint[nod] = dr-st+1;
        lazy_rem[nod] = 0;
        lazy_add[nod] = 0;
        if(st != dr){
            lazy_rem[nod*2] = 1;
            lazy_rem[nod*2+1] = 1;
            lazy_add[nod*2] = 0;
            lazy_add[nod*2+1] = 0;
        }
    }
    if(lazy_add[nod]){
        aintl[nod] = 0;
        aintr[nod] = 0;
        aint[nod] = 0;
        lazy_add[nod] = 0;
        lazy_rem[nod] = 0;
        if(st != dr){
            lazy_add[nod*2] = 1;
            lazy_add[nod*2+1] = 1;
            lazy_rem[nod*2] = 0;
            lazy_rem[nod*2+1] = 0;
        }
    }
    if(st >= l && dr <= r){
        aintl[nod] = 0;
        aintr[nod] = 0;
        aint[nod] = 0;
        if(st != dr){
            lazy_add[nod*2] = 1;
            lazy_add[nod*2+1] = 1;
            lazy_rem[nod*2] = 0;
            lazy_rem[nod*2+1] = 0;
        }
        return;
    }
    if(st > r || dr < l)
        return;
    int m = (st+dr)/2;
    update_add(nod*2, st, m, l, r);
    update_add(nod*2+1, m+1, dr, l, r);
    aintr[nod] = aintr[nod*2+1];
    if(aintr[nod*2+1] == dr-m)
        aintr[nod] += aintr[nod*2];
    aintl[nod] = aintl[nod*2];
    if(aintl[nod*2] == m-st+1)
        aintl[nod] += aintl[nod*2+1];
    aint[nod] = max(aint[nod*2], aint[nod*2+1]);
    aint[nod] = max(aint[nod], aintr[nod*2]+aintl[nod*2+1]);
}

void update_rem(int nod, int st, int dr, int l, int r)
{
    if(lazy_add[nod]){
        aintl[nod] = 0;
        aintr[nod] = 0;
        aint[nod] = 0;
        lazy_add[nod] = 0;
        lazy_rem[nod] = 0;
        if(st != dr){
            lazy_add[nod*2] = 1;
            lazy_add[nod*2+1] = 1;
            lazy_rem[nod*2] = 0;
            lazy_rem[nod*2+1] = 0;
        }
    }
    if(lazy_rem[nod]){
        aintl[nod] = dr-st+1;
        aintr[nod] = dr-st+1;
        aint[nod] = dr-st+1;
        lazy_rem[nod] = 0;
        lazy_add[nod] = 0;
        if(st != dr){
            lazy_rem[nod*2] = 1;
            lazy_rem[nod*2+1] = 1;
            lazy_add[nod*2] = 0;
            lazy_add[nod*2+1] = 0;
        }
    }
    if(st >= l && dr <= r){
        aintl[nod] = dr-st+1;
        aintr[nod] = dr-st+1;
        aint[nod] = dr-st+1;
        if(st != dr){
            lazy_rem[nod*2] = 1;
            lazy_rem[nod*2+1] = 1;
            lazy_add[nod*2] = 0;
            lazy_add[nod*2+1] = 0;
        }
        return;
    }
    if(st > r || dr < l)
        return;
    int m = (st+dr)/2;
    update_rem(nod*2, st, m, l, r);
    update_rem(nod*2+1, m+1, dr, l, r);
    aintr[nod] = aintr[nod*2+1];
    if(aintr[nod*2+1] == dr-m)
        aintr[nod] += aintr[nod*2];
    aintl[nod] = aintl[nod*2];
    if(aintl[nod*2] == m-st+1)
        aintl[nod] += aintl[nod*2+1];
    aint[nod] = max(aint[nod*2], aint[nod*2+1]);
    aint[nod] = max(aint[nod], aintr[nod*2]+aintl[nod*2+1]);
}

int query(int nod, int st, int dr, int l, int r)
{
    if(lazy_add[nod]){
        aintl[nod] = 0;
        aintr[nod] = 0;
        aint[nod] = 0;
        lazy_add[nod] = 0;
        lazy_rem[nod] = 0;
        if(st != dr){
            lazy_add[nod*2] = 1;
            lazy_add[nod*2+1] = 1;
            lazy_rem[nod*2] = 0;
            lazy_rem[nod*2+1] = 0;
        }
    }
    if(lazy_rem[nod]){
        aintl[nod] = dr-st+1;
        aintr[nod] = dr-st+1;
        aint[nod] = dr-st+1;
        lazy_rem[nod] = 0;
        lazy_add[nod] = 0;
        if(st != dr){
            lazy_rem[nod*2] = 1;
            lazy_rem[nod*2+1] = 1;
            lazy_add[nod*2] = 0;
            lazy_add[nod*2+1] = 0;
        }
    }
    int m = (st+dr)/2;
    if(st >= l && dr <= r){
        if(st != dr){
            propagate(nod*2, st, m);
            propagate(nod*2+1, m+1, dr);
        }
        return max(aint[nod], aintr[nod*2]+aintl[nod*2+1]);
    }
    if(l >= m+1)
        return query(nod*2+1, m+1, dr, l, r);
    if(r <= m)
        return query(nod*2, st, m, l, r);
    int ans, L = min(aintr[nod*2], m-l+1), R = min(aintl[nod*2+1], r-m);
    ans = L+R;
    ans = max(ans, query(nod*2, st, m, l, r));
    ans = max(ans, query(nod*2+1, m+1, dr, l, r));
    return ans;
}

void init(int nod, int st, int dr)
{
    aintl[nod] = dr-st+1;
    aintr[nod] = dr-st+1;
    aint[nod] = dr-st+1;
    if(st != dr){
        int m = (st+dr)/2;
        init(nod*2, st, m);
        init(nod*2+1, m+1, dr);
    }
}

int main()
{
    ifstream fin ("hotel.in");
    ofstream fout ("hotel.out");
    fin >> n >> test;
    init(1, 1, n);
    for (int tst = 1; tst <= test; ++tst){
        int t;
        fin >> t;
        if(t == 1){
            int x, y;
            fin >> x >> y;
            y = x+y-1;
            update_add(1, 1, n, x, y);
        }else if (t == 2){
            int x, y;
            fin >> x >> y;
            y = x+y-1;
            update_rem(1, 1, n, x, y);
        }else{
            fout << query(1, 1, n, 1, n) << "\n";
        }
    }
    return 0;
}