#include<fstream>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<climits>
#include<iomanip>
#include<cstring>
#include<bitset>

#define DIM 100000

using namespace std;

//ifstream f("hotel.in");
//ofstream g("hotel.out");

ifstream f("in.in");
ofstream g("out.out");

struct info{
    long long ssmax;
    long long ssst;
    long long ssdr;
    long long sum;

    long long len=0;

    long long coverval = -1;
}aint[5*DIM];

long long n,m,sol,a,b,x,t;

void createInfo(info &s,info a,info b){
    s.ssmax = max(max(a.ssmax,b.ssmax),a.ssdr+b.ssst);

    if(a.sum == a.len){
        s.ssst = a.sum+b.ssst;
    }else{
        s.ssst = a.ssst;
    }

    if(b.sum == b.len){
        s.ssdr = a.ssdr + b.sum;
    }else{
        s.ssdr = b.ssdr;
    }

    s.sum = a.sum+b.sum;
}

void build(long long nod,long long st,long long dr){
    if(st == dr){
        aint[nod].ssmax = 1;
        aint[nod].ssst = 1;
        aint[nod].ssdr = 1;
        aint[nod].sum = 1;

        aint[nod].len = 1;
    }else{

        long long mid = (st+dr)/2;

        build(2*nod,st,mid);
        build(2*nod+1,mid+1,dr);

        createInfo(aint[nod],aint[2*nod],aint[2*nod+1]);
        aint[nod].len = aint[2*nod].len + aint[2*nod+1].len;
    }
}

void afisare(long long nod,long long st,long long dr){
    if(st == dr){
        cout<<st<<"="<<aint[nod].ssmax<<'\n';
    }else{

        if(aint[nod].coverval != -1){
            aint[2*nod].ssmax = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].ssst = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].ssdr = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].sum = aint[nod].coverval * aint[2*nod].len;

            aint[2*nod].coverval = aint[nod].coverval;

            aint[2*nod+1].ssmax = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].ssst = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].ssdr = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].sum = aint[nod].coverval * aint[2*nod+1].len;

            aint[2*nod+1].coverval = aint[nod].coverval;


            aint[nod].coverval = -1;
        }

        long long mid = (st+dr)/2;

        cout<<st<<"-"<<dr<<"= ["<<aint[nod].ssmax<<" "<<aint[nod].ssst<<" "<<aint[nod].ssdr<<" "<<aint[nod].sum<<" "<<aint[nod].len<<"]"<<'\n';

        afisare(2*nod,st,mid);
        afisare(2*nod+1,mid+1,dr);
    }
    if(nod == 1){
        cout<<'\n';
    }
}

void update(int nod,int st,int dr,int a,int b,int val){

    if(a<=st && dr<=b){
        aint[nod].ssmax = val;
        aint[nod].ssst = val;
        aint[nod].ssdr = val;
        aint[nod].sum = val;

        aint[nod].coverval = val;
    }else{

        if(aint[nod].coverval != -1){
            aint[2*nod].ssmax = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].ssst = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].ssdr = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].sum = aint[nod].coverval * aint[2*nod].len;

            aint[2*nod].coverval = aint[nod].coverval;

            aint[2*nod+1].ssmax = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].ssst = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].ssdr = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].sum = aint[nod].coverval * aint[2*nod+1].len;

            aint[2*nod+1].coverval = aint[nod].coverval;


            aint[nod].coverval = -1;
        }

        long long mid = (st+dr)/2;

        if(a<=mid){
            update(2*nod,st,mid,a,b,val);
        }
        if(mid+1<=b){
            update(2*nod+1,mid+1,dr,a,b,val);
        }

        createInfo(aint[nod],aint[2*nod],aint[2*nod+1]);
    }

}

info query(long long nod,long long st,long long dr,long long a,long long b){
    if(a<=st && dr<=b){
        return aint[nod];
    }else{

        if(aint[nod].coverval != -1){
            aint[2*nod].ssmax = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].ssst = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].ssdr = aint[nod].coverval * aint[2*nod].len;
            aint[2*nod].sum = aint[nod].coverval * aint[2*nod].len;

            aint[2*nod].coverval = aint[nod].coverval;

            aint[2*nod+1].ssmax = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].ssst = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].ssdr = aint[nod].coverval * aint[2*nod+1].len;
            aint[2*nod+1].sum = aint[nod].coverval * aint[2*nod+1].len;

            aint[2*nod+1].coverval = aint[nod].coverval;


            aint[nod].coverval = -1;
        }

        long long mid = (st+dr)/2;

        info x,y;

        if(a<=mid){
            x=query(2*nod,st,mid,a,b);
        }
        if(mid+1<=b){
            y=query(2*nod+1,mid+1,dr,a,b);
        }
        if(a<=mid && mid+1<=b){
            info rez;
            createInfo(rez,x,y);
            return rez;
        }else{
            if(a<=mid){
                return x;
            }else{
                return y;
            }
        }
    }
}

signed main(){

    f>>n>>m;
    build(1,1,n);

    for(long long i=1;i<=m;i++){
        f>>t;
        if(t==1){
            f>>a>>x;
            b=a+x-1;
            update(1,1,n,a,b,0);
        }else if(t==2){
            f>>a>>x;
            b = a+x-1;
            update(1,1,n,a,b,1);
        }else{
            /*afisare(1,1,n);
            cout<<'\n';
            for(int i=1;i<=n;i++){
                cout<<query(1,1,n,i,i).ssmax<<" ";
            }
            cout<<'\n'<<'\n';*/

            g<<aint[1].ssmax<<'\n';
        }

    }

    f.close();
    g.close();
    return 0;
}