#include <bits/stdc++.h>
using namespace std;
ifstream f("hotel.in");
ofstream g("hotel.out");
constexpr int N = 100;
struct node {
    int lmax;
    int stmax;
    int drmax;
    int lazy;
};

node tree[N*4-1];
void update_node(int node, int left, int right)
{
    tree[node].lmax=max(max(tree[node*2].lmax, tree[node*2+1].lmax), tree[node*2].drmax+tree[node*2+1].stmax);
    int mid=(right+left)/2;
    if(tree[node*2].stmax >= mid-left+1)
    {
        // FULL INTERVAL
        tree[node].stmax=mid-left+1+tree[node*2+1].stmax;
    }else {
        tree[node].stmax=tree[node*2].stmax;
    }
    if(tree[node*2+1].drmax >= right-mid)
    {
        // FULL INTERVAL
        tree[node].drmax=right-mid+tree[node*2].drmax;
    }else {
        tree[node].drmax=tree[node*2+1].drmax;
    }
}
void build(int node ,int left, int right)
{


    if(left!=right)
    {
        int mid = (left+right)/2;
        build(node*2, left, mid);
        build(node*2+1, mid+1, right);
        update_node(node, left, right);
    }else {
        tree[node].lmax=1;
        tree[node].stmax=1;
        tree[node].drmax=1;
    }
}
void update_lazy(int node, int left, int right)
{
    switch(tree[node].lazy)
    {
    case 1:
        {
            if(left==right)
            {
                tree[node].drmax=0;
                tree[node].stmax=0;
                tree[node].lmax=0;
                tree[node].lazy=0;
            }else {
                tree[node*2].lazy=1;
                tree[node*2+1].lazy=1;
            }

        }
        break;
    case 2:
        {
            if(left==right)
            {
                tree[node].drmax=1;
                tree[node].stmax=1;
                tree[node].lmax=1;
                tree[node].lazy=0;
            }else {
                tree[node*2].lazy=1;
                tree[node*2+1].lazy=1;
            }
        }
        break;

    }

}
void update(int node, int left, int right, int qleft, int qright, int value)
{
    update_lazy(node,left,right);
    if(qleft<=left&&right<=qright)
    {
        tree[node].lazy=value;
        update_lazy(node, left, right);
    }else
    {
        int mid=(left+right)/2;
        if(qleft<=mid)
            update(node*2, left, mid, qleft, qright, value);
        if(mid+1<=qright)
            update(node*2+1, mid+1, right, qleft, qright, value);
        update_lazy(node*2, left, mid);
        update_lazy(node*2+1, mid+1, right);
        update_node(node, left, right);
    }
}
int main()
{
    int n, p;
    f>>n>>p;
    build(1,1,n);
    for(int i=0,a,b,c;i<p;i++)
    {

        f>>a;
        if(a==3)
        {
            g<<tree[1].lmax<<'\n';
        }else {
            f>>b>>c;
            if(a==1)
                update(1,1,n,b, b+c-1, 1);
            if(a==2)
                update(1,1,n,b,b+c-1, 2);
        }
    }
    return 0;
}