#include <iostream>
#include <fstream>
#include <stdio.h>

using namespace std;

const int NMAX = 1e5;

int suf[4 * NMAX];
int pref[4 * NMAX];
int l[4 * NMAX];
int lazy[4 * NMAX];

int val;

void propag( int st, int dr, int i ) {
    if ( lazy[i] != -1 ) {
        int mij = ( st + dr ) / 2;
        suf[i * 2 + 2] = pref[i * 2 + 2] = l[i * 2 + 2] = lazy[i] * ( dr - mij );
        suf[i * 2 + 1] = pref[i * 2 + 1] = l[i * 2 + 1] = lazy[i] * ( mij - st + 1 );
        lazy[i * 2 + 1] = lazy[i * 2 + 2] = lazy[i];
        lazy[i] = -1;
    }
}

void update( int a, int b, int st, int dr, int i ) {
    propag( st, dr, i );
    if ( a == st && b == dr ) { /// Intervalul acesta se stie sigur ca se va goli/umple
        l[i] = suf[i] = pref[i] = val * ( dr - st + 1 );
        lazy[i] = val;
    } else {
        int mij = ( st + dr ) / 2;
        if ( b <= mij )
            update( a, b, st, mij, i * 2 + 1 );
        else if ( a > mij )
            update( a, b, mij + 1, dr, i * 2 + 2 );
        else {
            update( a, mij, st, mij, i * 2 + 1 );
            update( mij + 1, b, mij + 1, dr, i * 2 + 2 );
        }
        suf[i] = suf[i * 2 + 2]; /// Stim garantat ca sufixul este minim sufixul intervalului mai mic
        if ( suf[i * 2 + 2] == dr - mij ) /// Insa daca intervalul mai mic este plin de unu atunci la el se mai adauga si sufixul celuilalt interval mai mic
            suf[i] += suf[i * 2 + 1];
        pref[i] = pref[i * 2 + 1]; /// Analog si pentru prefixe;
        if ( pref[i * 2 + 1] == mij - st + 1 )
            pref[i] += pref[i * 2 + 2];
        l[i] = max( max( l[i * 2 + 1], l[i * 2 + 2] ),
                        suf[i * 2 + 1] + pref[i * 2 + 2] );
        /// lugimea maxim de 0 este maximul dintre
        /// Lungimea intervalului mai mic din stanga  ( left_son  )
        /// Lungimea intervalului mai mic din dreapta ( right_son )
        /// Lungimea celui mai lung sufix din  ( left_son  ) +
        /// Lungimea celui mai lung prefix din ( right_son )
    }
}

int main() {
    ifstream fin( "hotel.in" );
    ofstream fout( "hotel.out" );
    int n, p, i, a, b;
    fin >> n >> p;
    val = 1;
    for ( i = 0; i < 4 * NMAX; i ++ ) {
        lazy[i] = -1;
    }
    update( 0, n - 1, 0, n - 1, 0 );
    for ( i = 0; i < p; i ++ ) {
        fin >> val;
        if ( val == 3 ) {
            fout << l[0] << endl;
        } else {
            val --;
            fin >> a >> b;
            a --;
            b --;
            update( a, a + b, 0, n - 1, 0 );
        }
    }
    fin.close();
    fout.close();
    return 0;
}