#include <fstream>
#define LL long long
#define VAL 400005
#define INF 1000000000000000000

using namespace std;

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

struct NODES
{
    LL STOT, SBEG, SEND, SBEST;
    int lazy, LTOT, LBEG, LEND, LBEST;
};

NODES ARB[VAL];

int N, P, i, op, A, B;
LL ANS;

void Calcule(int nod)
{
    int st=2*nod, dr=2*nod+1;
    ARB[nod].STOT=ARB[st].STOT+ARB[dr].STOT;
    ARB[nod].LTOT=ARB[st].LTOT+ARB[dr].LTOT;
    ARB[nod].SBEG=max(ARB[st].SBEG, ARB[st].STOT+ARB[dr].SBEG);
    if (ARB[st].SBEG>=ARB[st].STOT+ARB[dr].SBEG)
        ARB[nod].LBEG=ARB[st].LBEG;
    else
        ARB[nod].LBEG=ARB[st].LTOT+ARB[dr].LBEG;
    ARB[nod].SEND=max(ARB[dr].SEND, ARB[st].SEND+ARB[dr].STOT);
    if (ARB[dr].SEND>=ARB[st].SEND+ARB[dr].STOT)
        ARB[nod].LEND=ARB[dr].LEND;
    else
        ARB[nod].LEND=ARB[st].LEND+ARB[dr].LTOT;
    ARB[nod].SBEST=max(ARB[st].SBEST, ARB[dr].SBEST);
    ARB[nod].SBEST=max(ARB[nod].SBEST, ARB[st].SEND+ARB[dr].SBEG);
    if (ARB[nod].SBEST==ARB[st].SEND+ARB[dr].SBEG)
        ARB[nod].LBEST=ARB[st].LEND+ARB[dr].LBEG;
    if (ARB[nod].SBEST==ARB[st].SBEST)
        ARB[nod].LBEST=ARB[st].LBEST;
    if (ARB[nod].SBEST==ARB[dr].SEND)
        ARB[nod].LBEST=ARB[dr].LBEST;
}

void Initializare(int nod, int be, int en)
{
    if (be==en)
    {
        ARB[nod].STOT=ARB[nod].SBEST=ARB[nod].SBEG=ARB[nod].SEND=1;
        ARB[nod].LTOT=ARB[nod].LBEST=ARB[nod].LBEG=ARB[nod].LEND=1;
        return;
    }
    int mid=(be+en) / 2;
    Initializare(2*nod, be, mid);
    Initializare(2*nod+1, mid+1, en);
    Calcule(nod);
}

void Propagate(int nod, int be, int en)
{
    if (ARB[nod].lazy==0)
        return;
    if (ARB[nod].lazy>0)
    {
        ARB[nod].STOT=ARB[nod].SBEST=ARB[nod].LTOT;
        ARB[nod].SBEG=ARB[nod].SEND=ARB[nod].LTOT;
        ARB[nod].LBEG=ARB[nod].LEND=ARB[nod].LBEST=ARB[nod].LTOT;
    }
    else
    {
        ARB[nod].STOT=1LL*(-N)*ARB[nod].LTOT;
        ARB[nod].SBEG=ARB[nod].SEND=ARB[nod].SBEST=-N;
        ARB[nod].LBEG=ARB[nod].LEND=ARB[nod].LBEST=1;
    }
    if (be<en)
    {
        ARB[2*nod].lazy+=ARB[nod].lazy;
        ARB[2*nod+1].lazy+=ARB[nod].lazy;
    }
    ARB[nod].lazy=0;
}

void Update(int nod, int be, int en, int A, int B, LL X)
{
    Propagate(nod, be, en);
    if (A<=be && en<=B)
    {
        ARB[nod].lazy+=X;
        return;
    }
    int mid=(be+en) / 2;
    if (max(be, A)<=min(mid, B))
        Update(2*nod, be, mid, A, B, X);
    if (max(mid+1, A)<=min(en, B))
        Update(2*nod+1, mid+1, en, A, B, X);
    Propagate(2*nod, be, mid);
    Propagate(2*nod+1, mid+1, en);
    Calcule(nod);
}

int main()
{
    fin >> N >> P;
    Initializare(1, 1, N);
    for (i=1; i<=P; i++)
    {
        fin >> op;
        if (op==3)
        {
            Propagate(1, 1, N);
            fout << max(0LL, ARB[1].SBEST) << '\n';
            continue;
        }
        fin >> A >> B;
        B+=A-1;
        if (op==1)
            Update(1, 1, N, A, B, -N-1);
        else
            Update(1, 1, N, A, B, N+1);
    }
    fin.close();
    fout.close();
    return 0;
}