#include <bits/stdc++.h>

const std :: string FILENAME = "hotel";

std :: ifstream in (FILENAME + ".in");

std :: ofstream out (FILENAME + ".out");

const int NMAX = 1e5 + 5;

struct nod
{
    int secv_max, pref, suf;
};

int n;

int q;

int cer;

int x;

int y;

int val;

nod arb[4 * NMAX];

int putoare[4 * NMAX];

void gen(int nod, int st, int dr)
{
    if(st == dr)
    {
        arb[nod].secv_max = arb[nod].pref = arb[nod].suf = 1;
    }
    else
    {
        int mij = (st + dr) / 2;

        gen(nod * 2, st, mij);

        gen(nod * 2 + 1, mij + 1, dr);

        arb[nod].secv_max = arb[nod].pref = arb[nod].suf = dr - st + 1;
    }
}

void lazy_propagation(int nod, int st, int dr)
{
    if(putoare[nod])
    {
         arb[nod].secv_max = arb[nod].pref = arb[nod].suf = (putoare[nod] == 1) ? 0 : (dr - st + 1);

         if(st != dr)
         {
             putoare[nod * 2] = putoare[nod];

             putoare[nod * 2 + 1] = putoare[nod];
         }

         putoare[nod] = 0;
    }
}

void lazy_update(int nod, int st, int dr)
{
    if(x <= st && y >= dr)
    {
        putoare[nod] = val;
    }
    else
    {
        lazy_propagation(nod, st, dr);

        int mij = (st + dr) / 2;

        if(x <= mij)
        {
            lazy_update(nod * 2, st, mij);
        }
        if(y > mij)
        {
            lazy_update(nod * 2 + 1, mij + 1, dr);
        }

        lazy_propagation(nod * 2, st, mij);

        lazy_propagation(nod * 2 + 1, mij + 1, dr);

        arb[nod].secv_max = std :: max({arb[nod * 2].secv_max, arb[nod * 2 + 1].secv_max, arb[nod * 2].suf + arb[nod * 2 + 1].pref});

        arb[nod].pref = (arb[nod * 2].pref == mij - st + 1) ? (arb[nod * 2].pref + arb[nod * 2 + 1].pref) : arb[nod * 2].pref;

        arb[nod].suf = (arb[nod * 2 + 1].suf == dr - mij) ? (arb[nod * 2 + 1].suf + arb[nod * 2].suf) : arb[nod * 2 + 1].suf;
    }
}

int main()
{

    in >> n >> q;

    gen(1, 1, n);

    while(q --)
    {
        in >> cer;

        if(cer == 1)
        {
            in >> x >> y;

            y += x - 1;

            val = 1;

            lazy_update(1, 1, n);
        }
        else if(cer == 2)
        {
            in >> x >> y;

            y += x - 1;

            val = -1;

            lazy_update(1, 1, n);
        }
        else
        {
            lazy_propagation(1, 1, n);

            out << arb[1].secv_max << '\n';
        }
    }

    return 0;
}