#include <fstream>
#include <algorithm>

using namespace std;

const int N_MAX = 200000;

struct room
{
    int left;
    int right;
    int maxi;
    bool free;
};

room arbint[4 * N_MAX + 1];

room join(room a, room b)
{
    room c;
    c.left = a.left;
    c.right = b.right;
    c.maxi = max( a.right + b.left, max(a.maxi, b.maxi ) );
    if( a.free )
        c.left += b.left;
    if( b.free )
        c.right += a.right;
    if(a.free && b.free )
        c.free = true;
    else
        c.free = false;
    if( !a.free && !b.free )
        c.free = false;
    else
        c.free = true;
    return c;
}

void set_free(int node, int left, int right)
{
    arbint[node].left = right - left + 1;
    arbint[node].right = right - left + 1;
    arbint[node].maxi = right - left + 1;
    arbint[node].free = true;
}

void set_notfree(int node, int left, int right)
{
    arbint[node].left = 0;
    arbint[node].right = 0;
    arbint[node].maxi = 0;
    arbint[node].free = false;
}

void build(int node, int left, int right)
{
    if(left == right)
        set_free( node , left , right );
    else
    {
        int mid = ( left + right ) / 2;
        build( 2 * node , left , mid );
        build(2 * node + 1 , mid + 1 , right);
        arbint[node] = join( arbint[2 * node] , arbint[2 * node + 1] );
    }
}

void update( int node , int left , int right , int x , int y , bool free)
{
    if( arbint[node].free )
    {
        int mid = ( left + right ) / 2;
        set_free( 2 * node , left , mid );
        set_free( 2 * node + 1 , mid + 1 , right );
    }
    if( !arbint[node].free )
    {
        int mid = ( left + right ) / 2;
        set_notfree( 2 * node , left , mid );
        set_notfree( 2 * node + 1 , mid + 1 , right );
    }
    if( x <= left && right <= y )
    {
        if( !free )
            set_notfree( node , left , right );
        else
            set_free( node , left , right );
    }
    else
    {
        int mid = ( left + right ) / 2;
        if( x <= mid )
            update( 2 * node , left , mid , x , y , free );
        if( y >= mid + 1 )
            update( 2 * node + 1 , mid + 1 , right , x , y , free );
        arbint[node] = join( arbint[2 * node] , arbint[2 * node + 1] );
    }
}

int main()
{
    ifstream fin("hotel.in");
    ofstream fout("hotel.out");
    int n , p;
    fin >> n >> p;
    build( 1 , 1 , n );
    for( int i = 1 ; i <= p ; ++i )
    {
        int c;
        fin >> c;
        if( c == 1 )
        {
            int x , y;
            fin >> x >> y;
            update( 1 , 1 , n , x , x + y - 1 , false );
        }
        else if( c == 2 )
        {
            int x , y;
            fin >> x >> y;
            update( 1 , 1 , n , x , x + y - 1 , true );
        }
        else if( c == 3 )
            fout << arbint[1].maxi << '\n';
    }
    return 0;
}