#include <bits/stdc++.h>
#define DIM 100005

using namespace std;

ifstream f("hotel.in");
ofstream g("hotel.out");

int n, m;

struct elem
{
    int suff;
    int pref;
    int best;
    int lazy;

    elem()
    {
        lazy = -1;
    }
}aint[4 * DIM];

void lazyUpdate(int nod, int st, int dr)
{
    if (aint[nod].lazy == -1)
        return;

    int childSt = 0, childDr = 0;
    if (st != dr)
        childSt = 2 * nod, childDr = 2 * nod + 1;
    if (aint[nod].lazy == 1)
    {
        aint[nod].suff = dr - st + 1;
        aint[nod].pref = dr - st + 1;
        aint[nod].best = dr - st + 1;
    }
    else if (aint[nod].lazy == 0)
    {
        aint[nod].suff = 0;
        aint[nod].pref = 0;
        aint[nod].best = 0;
    }
    aint[childSt].lazy = aint[childDr].lazy = aint[nod].lazy;
    aint[nod].lazy = -1;
}

void UpdateNode(int nod, int st, int dr)
{
    int childSt = 2 * nod;
    int childDr = 2 * nod + 1;
    int mid = (st + dr) / 2;

    //suff
    aint[nod].suff = aint[childDr].suff;
    if (aint[nod].suff == dr - mid)
        aint[nod].suff += aint[childSt].suff;

    //pref
    aint[nod].pref = aint[childSt].pref;
    if (aint[nod].pref == mid - st + 1)
        aint[nod].pref += aint[childDr].pref;

    //best
    aint[nod].best = max(aint[childSt].best, max(aint[childDr].best, aint[childSt].suff + aint[childDr].pref));
}


void Update(int nod, int st, int dr, int stU, int drU, int val)
{
    if (stU <= st && dr <= drU)
    {
        aint[nod].lazy = val;
        return ;
    }

    lazyUpdate(nod, st, dr);
    int mid = (st + dr) / 2;

    if (stU <= mid)
        Update(2 * nod, st, mid, stU, drU, val);
    if (mid < drU)
        Update(2 * nod + 1, mid + 1, dr, stU, drU, val);

    lazyUpdate(2 * nod, st, mid);
    lazyUpdate(2 * nod + 1, mid + 1, dr);

    UpdateNode(nod, st, dr);

}

int main()
{
    f >> n >> m;

    aint[1].lazy = 1;
    for (int i = 1; i <= m; i++)
    {
        int ops;
        f >> ops;
        if (ops == 1)
        {
            int start, cnt;
            f >> start >> cnt;
            Update(1, 1, n, start, start + cnt - 1, 0);
        }
        if (ops == 2)
        {
            int start, cnt;
            f >> start >> cnt;
            Update(1, 1, n, start, start + cnt - 1, 1);
        }
        if (ops == 3)
        {
            lazyUpdate(1, 1, n);
            g << aint[1].best << "\n";
        }
    }

    return 0;
}