#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstring>
#define maxn 100001
using namespace std;

int n, q;
int tree[maxn*4+66], maxim, start, finish, k;
int lef[maxn*4+66][2], cen[maxn*4+66][2], rig[maxn*4+66][2];

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

void upfill(int nod, int left, int right)
{
    tree[nod]=k;
    if(left<right)
    {
        int mid=(left+right)/2;
        upfill(nod*2,left,mid);
        upfill(nod*2+1,mid+1,right);
    }
}

void update(int nod, int left, int right)
{
    int mid=(left+right)/2;

    if(start<=left&&right<=finish)
    {
        tree[nod]=k;
        if(left<right)
        {
            upfill(nod*2,left,mid);
            upfill(nod*2+1,mid+1,right);
        }
    }
    else
    {
        tree[nod]=-1;

        if(start<=mid)
            update(nod*2,left,mid);

        if(mid<finish)
            update(nod*2+1,mid+1,right);

        if(tree[nod*2]==tree[nod*2+1])
            tree[nod]=tree[nod*2];
    }
}

void query(int nod, int left, int right)
{
    int mid=(left+right)/2;
    if(tree[nod*2]==1)
    {
        if(tree[nod*2+1]==-1)
        {
            query(nod*2+1,mid+1,right);
        }
        else
        {
            lef[nod*2+1][0]=cen[nod*2+1][0]=rig[nod*2+1][0]=mid+1;
            lef[nod*2+1][1]=cen[nod*2+1][1]=rig[nod*2+1][1]=right;
        }

        lef[nod][0]=lef[nod*2+1][0];
        lef[nod][1]=lef[nod*2+1][1];
        rig[nod][0]=rig[nod*2+1][0];
        rig[nod][1]=rig[nod*2+1][1];
        cen[nod][0]=cen[nod*2+1][0];
        cen[nod][1]=cen[nod*2+1][1];
    }
    else if(tree[nod*2+1]==1)
    {
        if(tree[nod*2]==-1)
        {
            query(nod*2,left,mid);
        }
        else
        {
            lef[nod*2][0]=cen[nod*2][0]=rig[nod*2][0]=left;
            lef[nod*2][1]=cen[nod*2][1]=rig[nod*2][1]=mid;
        }
        lef[nod][0]=lef[nod*2][0];
        lef[nod][1]=lef[nod*2][1];
        rig[nod][0]=rig[nod*2][0];
        rig[nod][1]=rig[nod*2][1];
        cen[nod][0]=cen[nod*2][0];
        cen[nod][1]=cen[nod*2][1];
    }
    else
    {
        if(tree[nod*2]==-1)
        {
            query(nod*2,left,mid);
        }
        else
        {
            lef[nod*2][0]=cen[nod*2][0]=rig[nod*2][0]=left;
            lef[nod*2][1]=cen[nod*2][1]=rig[nod*2][1]=mid;
        }

        if(tree[nod*2+1]==-1)
        {
            query(nod*2+1,mid+1,right);
        }
        else
        {
            lef[nod*2+1][0]=cen[nod*2+1][0]=rig[nod*2+1][0]=mid+1;
            lef[nod*2+1][1]=cen[nod*2+1][1]=rig[nod*2+1][1]=right;
        }
        lef[nod][0]=lef[nod*2][0];
        lef[nod][1]=lef[nod*2][1];
        rig[nod][0]=rig[nod*2+1][0];
        rig[nod][1]=rig[nod*2+1][1];
        int valmax=0;
        if(cen[nod*2][1]-cen[nod*2][0]>cen[nod*2+1][1]-cen[nod*2+1][0])
        {
            valmax=cen[nod*2][1]-cen[nod*2][0]+1;
            cen[nod][0]=cen[nod*2][0];
            cen[nod][1]=cen[nod*2][1];
        }
        else
        {
            valmax=cen[nod*2+1][1]-cen[nod*2+1][0]+1;
            cen[nod][0]=cen[nod*2+1][0];
            cen[nod][1]=cen[nod*2+1][1];
        }
        if(rig[2*nod][1]+1==lef[2*nod+1][0]&&lef[nod*2+1][1]-rig[nod*2][0]+1>valmax)
        {
            cen[nod][0]=rig[nod*2][0];
            cen[nod][1]=lef[nod*2+1][1];
        }
    }
    if(lef[nod][1]+1>=cen[nod][0]&&cen[nod][1]+1>=rig[nod][0])
    {
        cen[nod][0]=rig[nod][0]=lef[nod][0];
        cen[nod][1]=lef[nod][1]=rig[nod][1];
    }
    else
    {
        if(lef[nod][1]+1>=cen[nod][0])
        {
            cen[nod][0]=lef[nod][0];
            lef[nod][1]=cen[nod][1];
        }
        if(cen[nod][1]+1>=rig[nod][0])
        {
            cen[nod][1]=rig[nod][1];
            rig[nod][0]=cen[nod][0];
        }
    }
    /*if(nod==2)
    {
        fout<<lef[nod][0]<<' '<<lef[nod][1]<<' '<<cen[nod][0]<<' '<<cen[nod][1]<<' '<<rig[nod][0]<<' '<<rig[nod][1]<<'\n';
    }*/
}

int main()
{
    int op, pos, m;
    fin>>n>>q;
    while(q--)
    {
        fin>>op;
        if(op==1)
        {
            fin>>pos>>m;
            start=pos;
            finish=pos+m-1;
            k=1;
            update(1,1,n);
        }
        else if(op==2)
        {
            fin>>pos>>m;
            start=pos;
            finish=pos+m-1;
            k=0;
            update(1,1,n);
        }
        else
        {
            if(tree[1]==0)
            {
                fout<<n<<'\n';
            }
            else if(tree[1]==1)
            {
                fout<<0<<'\n';
            }
            else
            {
                query(1,1,n);
                maxim=max(max(lef[1][1]-lef[1][0],rig[1][1]-rig[1][0]),cen[1][1]-cen[1][0]);
                //fout<<lef[1][0]<<' '<<lef[1][1]<<' '<<cen[1][0]<<' '<<cen[1][1]<<' '<<rig[1][0]<<' '<<rig[1][1]<<'\n';
                fout<<maxim+1<<'\n';
            }
        }
    }
    return 0;
}