#include <fstream>
#include <algorithm>
#define MAXN 100000

using namespace std;

struct segNode {
  int pref, suff, maxl;
};

segNode tree[4 * MAXN + 1];
int lazy[4 * MAXN + 1];

static inline int lSon( int node ) {
  return 2 * node;
}
static inline int rSon( int node ) {
  return 2 * node + 1;
}

void build( int node, int st, int dr ) {
  int mij = (st + dr) / 2;

  if ( st == dr ) {
	tree[node].maxl = tree[node].pref = tree[node].suff = 1;
	return;
  }
  build( lSon( node ), st, mij );
  build( rSon( node ), mij + 1, dr );
  tree[node].maxl = tree[lSon( node )].maxl + tree[rSon( node )].maxl;   
  tree[node].pref = tree[lSon( node )].pref + tree[rSon( node )].pref; 
  tree[node].suff = tree[lSon( node )].suff + tree[rSon( node )].suff; 
}

static inline void fix( int node, int ll, int lr ) {
  if ( tree[lSon( node )].pref == ll ) {
	tree[node].pref = ll + tree[rSon( node )].pref;
  } else {
	tree[node].pref = tree[lSon( node )].pref;
  }
  if ( tree[rSon( node )].suff == lr ) {
	tree[node].suff = lr + tree[lSon( node )].suff;
  } else {
	tree[node].suff = tree[rSon( node )].suff;
  }
  tree[node].maxl = max( max( tree[lSon( node )].maxl, tree[rSon( node )].maxl ), (tree[lSon( node )].suff + tree[rSon( node )].pref) ); 
}
static inline void prop( int node, int st, int dr ) {
  int mij = (st + dr) / 2;

  if ( lazy[node] ) {
	if ( lazy[node] == 1 ) {
      tree[lSon( node )].pref = tree[rSon( node )].pref = 0;
	  tree[lSon( node )].suff = tree[rSon( node )].suff = 0;
	  tree[lSon( node )].maxl = tree[rSon( node )].maxl = 0;
	  lazy[lSon( node )] = lazy[rSon( node )] = 1;
	} else {
      tree[lSon( node )].pref = mij - st + 1, tree[rSon( node )].pref = dr - mij;
      tree[lSon( node )].suff = mij - st + 1, tree[rSon( node )].suff = dr - mij;
	  tree[lSon( node )].maxl = mij - st + 1, tree[rSon( node )].maxl = dr - mij;
	  lazy[lSon( node )] = lazy[rSon( node )] = 2;
	}
  }
  lazy[node] = 0;
}

void update( int node, int st, int dr, int x, int y, int c ) {
  int mij = (st + dr) / 2;

  if ( c == 1 ) {
    if ( x <= st && dr <= y ) {
	  lazy[node] = c;
      tree[node].maxl = tree[node].pref = tree[node].suff = 0; 
	  return;
    }
	prop( node, st, dr );
    if ( x <= mij ) {
	  update( lSon( node ), st, mij, x, y, c );
	}
    if ( y > mij ) {
	  update( rSon( node ), mij + 1, dr, x, y, c );
	}
    fix( node, mij - st + 1, dr - mij );
  } else {
	if ( x <= st && dr <= y ) {
      lazy[node] = c;
	  tree[node].maxl = tree[node].pref = tree[node].suff = dr - st + 1;
      return;
	}
	prop( node, st, dr );
	if ( x <= mij ) {
	  update( lSon( node ), st, mij, x, y, c );
	}
	if ( y > mij ) {
	  update( rSon( node ), mij + 1, dr, x, y, c );
	}
	fix( node, mij - st + 1, dr - mij );
  }
}

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

int main() {
  int n, q, type, i, m;
   
  fin >> n >> q;
  build( 1, 1, n );    
  while ( q-- ) {
	 fin >> type;
	 switch ( type ) {
	 case 1:
	 case 2:
	   fin >> i >> m;
	   update( 1, 1, n, i, i + m - 1, type );
	   break;
	 case 3:
       fout << tree[1].maxl << "\n";
	   break;
	 }
  }
  fin.close();
  fout.close();
  return 0;
}