#include<fstream>
#include<iostream>
#include<ctime>
using namespace std;

clock_t start=clock();

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

struct nod
{   int st, maxim, dr;
    bool updated;
};

int N, P;
int leftt, rightt, val;
nod arb[400001];

void build(int node, int st, int dr)
{   if(st == dr)
    {   arb[node].st = arb[node].dr = arb[node].maxim = 1;
        arb[node].updated = false;
        return;
    }

    int mid = (st + dr) / 2;
    build(2 * node, st, mid);
    build(2 * node + 1, mid + 1, dr);

    arb[node].maxim = arb[2 * node].st + arb[2 * node + 1].dr;
    arb[node].st = arb[node].dr = arb[node].maxim;
}

void update(int node, int st, int dr)
{   if(leftt <= st && dr <= rightt)
    {
        arb[node].maxim = arb[node].st = arb[node].dr = (val?(dr - st + 1):val);
        arb[node].updated = true;
        return;
    }

    int mid = (st + dr) / 2;

    if(arb[node].updated)
    {   arb[2 * node].maxim = arb[2 * node].st = arb[2 * node].dr = (val?0:(mid - st + 1));
        arb[2 * node].updated = true;

        arb[2 * node + 1].maxim = arb[2 * node + 1].st = arb[2 * node + 1].dr = (val?0:(dr - mid));
        arb[2 * node + 1].updated = true;

        arb[node].updated = false;
    }

    if(leftt <= mid)
        update(2 * node, st, mid);
    if(mid < rightt)
        update(2 * node + 1, mid + 1, dr);

    if(arb[2 * node].st == mid - st + 1)
        arb[node].st = arb[2 * node].st + arb[2 * node + 1].st;
    else arb[node].st = arb[2 * node].st;

    if(arb[2 * node + 1].dr == dr - mid)
        arb[node].dr = arb[2 * node + 1].dr + arb[2 * node].dr;
    else arb[node].dr = arb[2 * node + 1].dr;

    arb[node].maxim = max(arb[2 * node].dr + arb[2 * node + 1].st, max(arb[2 * node].maxim, arb[2 * node + 1].maxim));
}

int main()
{   int i, j, k, c;

    f>>N>>P;
    build(1, 1, N);

    for(i = 1; i <= P; i++)
    {   f>>c;
        if(c == 3)
            g<<arb[1].maxim<<'\n';
        else
        {   f>>j>>k;
            leftt = j; rightt = j + k - 1;
            val = (c == 1?0:1);
            update(1, 1, N);
        }
    }

    cout << 1.0*(clock()-start)/(1.0*CLOCKS_PER_SEC) << '\n';
    return 0;
}