#include <fstream>
using namespace std;

ifstream F("hotel.in");
ofstream G("hotel.out");

const int Nmax = 100010;

struct Arb_Int
{
    int left, right;
    int best, mark;
};

#define L_son (2*Nod)
#define R_son (2*Nod+1)

Arb_Int A[Nmax << 2];

int N,P;
int st,dr,type;

void Build(int Nod,int St,int Dr)
{
    if ( St == Dr )
    {
        A[Nod].left = A[Nod].right = A[Nod].best = 1;
        A[Nod].mark = 0;
        return;
    }

    int Mid = ( St + Dr ) / 2;

    if ( St <= Mid) Build( L_son , St  ,  Mid ), A[Nod].best += A[L_son].best;
    if ( Mid < Dr ) Build( R_son , Mid+1 , Dr ), A[Nod].best += A[R_son].best;

    A[Nod].left = A[Nod].right = A[Nod].best;
    A[Nod].mark = 0;
}

void Update(int Nod,int St,int Dr)
{
    if ( st <= St && Dr <= dr )
    {
        A[Nod].mark = type;
        return;
    }

    int Mid = (St + Dr) / 2;

    if ( A[Nod].mark == 1 && type == 0 ) A[L_son].mark = A[R_son].mark = 1;

    if ( st <= Mid ) Update( L_son , St  , Mid  );
    if ( Mid < dr )  Update( R_son , Mid+1 , Dr );

    if ( A[Nod].mark == 1 && A[L_son].mark + A[R_son].mark < 2 ) A[Nod].mark = 0;

    if ( A[Nod].mark == 1 ) return;

    if ( A[L_son].mark == 1 ) { A[Nod] = A[R_son]; A[Nod].left = 0;  return; }
    if ( A[R_son].mark == 1 ) { A[Nod] = A[L_son]; A[Nod].right = 0; return; }

    A[Nod].left = ( St + A[L_son].left == Mid+1 ) ? A[L_son].left + A[R_son].left : A[L_son].left;
    A[Nod].right = ( Dr - A[R_son].right == Mid ) ? A[R_son].right + A[L_son].right : A[R_son].right;

    A[Nod].best = max ( max( max( A[Nod].left , A[Nod].right ) , max( A[L_son].best , A[R_son].best ) ) , A[L_son].right + A[R_son].left );
}

int main()
{
    F>>N>>P;

    Build(1,1,N);

    for (int i=1;i<=P;++i)
    {
        F>>type, --type;
        if ( type < 2 )
        {
            F>>st>>dr;
            type = 1-type;
            dr += st-1;
            Update(1,1,N);
        }
        else
            if ( A[1].mark == 0 )
                G<<A[1].best<<'\n';
            else
                G<<"0\n";
    }
}