#include <iostream>
#include <fstream>
#include <algorithm>

const int N = 100000;

struct tree_node{
    int maxi;
    int pref;
    int suff;
    int lazy;
}segment_tree[4*N+1];

void update_node(int node, int left, int right)
{
    int m = (left + right) / 2;
    segment_tree[node].pref = ((segment_tree[node*2+1].pref == right - m)? segment_tree[node*2+1].pref + segment_tree[node*2].pref : segment_tree[node*2+1].pref);
    segment_tree[node].suff = ((segment_tree[node*2].suff == m - left + 1)? segment_tree[node*2].suff + segment_tree[node*2+1].suff : segment_tree[node*2].suff);
    segment_tree[node].maxi = std::max(segment_tree[node*2].pref + segment_tree[node*2+1].suff, std::max(segment_tree[node*2].maxi, segment_tree[node*2+1].maxi));
}

void update_lazy(int node, int left, int right)
{
    if(segment_tree[node].lazy == 1)
    {
        segment_tree[node].maxi = 0;
        segment_tree[node].pref = 0;
        segment_tree[node].suff = 0;
        if(left != right)
            segment_tree[node*2].lazy = 1, segment_tree[node*2+1].lazy = 1;

        segment_tree[node].lazy = 0;
    }
    else if(segment_tree[node].lazy == 2)
    {
        segment_tree[node].maxi = right - left + 1;
        segment_tree[node].pref = right - left + 1;
        segment_tree[node].suff = right - left + 1;
        if(left != right)
            segment_tree[node*2].lazy = 2, segment_tree[node*2+1].lazy = 2;
        segment_tree[node].lazy = 0;
    }
}

void update(int node, int left, int right, int q_left, int q_right, int state)
{
    if(q_left <= left && right <= q_right)
        segment_tree[node].lazy = state;
    else
    {
        int m = (left + right) / 2;
        update_lazy(node, left, right);
        if(q_left <= m)
            update(node*2, left, m, q_left, q_right, state);
        if(m+1<=q_right)
            update(node*2+1, m+1, right, q_left, q_right, state);
        update_lazy(node*2, left, m);
        update_lazy(node*2+1, m+1, right);
        update_node(node, left, right);
    }
}

/**
    12 10

    0 0 0 0 0 0 0 0 0 0 0 0

    3 -> 12
    1 2 3
    0 1 1 1 0 0 0 0 0 0 0 0
    1 9 4
    0 1 1 1 0 0 0 0 1 1 1 1
    3 -> 4
    2 2 1
    0 0 1 1 0 0 0 0 1 1 1 1
    3 -> 4
    2 9 2
    0 0 1 1 0 0 0 0 0 0 1 1
    3 -> 6
    2 3 2
    0 0 0 0 0 0 0 0 0 0 1 1
    3 -> 10
*/

int main()
{
    std::ifstream fin("hotel.in");
    std::ofstream fout("hotel.out");
    int n, p, c, a, b;
    fin >> n >> p;
    segment_tree[1].lazy = 2;
    while(p--)
    {
        fin >> c;
        if(c == 3)
            update_lazy(1, 1, n), fout << segment_tree[1].maxi << '\n';
        else
        {
            fin >> a >> b;
            update(1, 1, n, a, a + b - 1, c);
        }
    }
    return 0;
}