#include <fstream>

using namespace std;

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

struct str{
    int sst, sdr, max1;
};

const int max_size = 4e5 + 1;

int lazy[max_size];
str aint[max_size];

void init (int l, int r, int nod)
{
    if (l == r)
    {
        aint[nod].max1 = 1;
        aint[nod].sdr = 1;
        aint[nod].sst = 1;
    }
    else
    {
        int m = (l + r) / 2;
        init(l, m, 2 * nod);
        init(m + 1, r, 2 * nod + 1);
        aint[nod].max1 = r - l + 1;
        aint[nod].sdr = r - l + 1;
        aint[nod].sst = r - l + 1;
    }
}

void push (int nod, int l, int r)
{
    if (lazy[nod] == -1)
    {
        aint[2 * nod].max1 = 0;
        aint[2 * nod].sdr = 0;
        aint[2 * nod].sst = 0;
        aint[2 * nod + 1].max1 = 0;
        aint[2 * nod + 1].sdr = 0;
        aint[2 * nod + 1].sst = 0;
        lazy[2 * nod] = -1;
        lazy[2 * nod + 1] = -1;
    }
    else
    {
        int m = (l + r) / 2;
        aint[2 * nod].max1 = m - l + 1;
        aint[2 * nod].sdr = m - l + 1;
        aint[2 * nod].sst = m - l + 1;
        aint[2 * nod + 1].max1 = r - m;
        aint[2 * nod + 1].sdr = r - m;
        aint[2 * nod + 1].sst = r - m;
        lazy[2 * nod] = 1;
        lazy[2 * nod + 1] = 1;
    }
    lazy[nod] = 0;
}

void upd (int l, int r, int st, int dr, int sgn, int nod)
{
    if (st > dr)
    {
        return;
    }
    if (l == st && r == dr)
    {
        if (sgn == 1)
        {
            aint[nod].max1 = r - l + 1;
            aint[nod].sdr = r - l + 1;
            aint[nod].sst = r - l + 1;
            lazy[nod] = 1;
        }
        else
        {
            aint[nod].max1 = 0;
            aint[nod].sdr = 0;
            aint[nod].sst = 0;
            lazy[nod] = -1;
        }
    }
    else
    {
        if (lazy[nod] != 0)
        {
            push(nod, l, r);
        }
        int m = (l + r) / 2;
        upd(l, m, st, min(dr, m), sgn, 2 * nod);
        upd(m + 1, r, max(st, m + 1), dr, sgn, 2 * nod + 1);
        /// st
        if (aint[2 * nod].sst == m - l + 1)
        {
            aint[nod].sst = aint[2 * nod].sst + aint[2 * nod + 1].sst;
        }
        else
        {
            aint[nod].sst = aint[2 * nod].sst;
        }
        /// dr
        if (aint[2 * nod + 1].sdr == r - m)
        {
            aint[nod].sdr = aint[2 * nod + 1].sdr + aint[2 * nod].sdr;
        }
        else
        {
            aint[nod].sdr = aint[2 * nod + 1].sdr;
        }
        aint[nod].max1 = max(aint[2 * nod].sdr + aint[2 * nod + 1].sst, max(aint[nod].sst, max(aint[nod].sdr, max(aint[2 * nod].max1, aint[2 * nod + 1].max1))));
    }
}

void afis (int l, int r, int nod)
{
    if (l == r)
    {
        out << l << " " << l << " " << aint[nod].max1 << " "  << aint[nod].sst << " " << aint[nod].sdr << '\n';
        out << '\n';
    }
    else
    {
        int m = (l + r) / 2;
        afis(l, m, 2 * nod);
        afis(m + 1, r, 2 * nod + 1);
        out << l << " " << r << " " << aint[nod].max1 << " "  << aint[nod].sst << " " << aint[nod].sdr << '\n';
        out << '\n';
    }
}

int main ()
{
    int q, n;
    in >> n >> q;
    init(1, n, 1);
    while (q--)
    {
        int op;
        in >> op;
        if (op == 1)
        {
            int x, y;
            in >> x >> y;
            upd(1, n, x, x + y - 1, -1, 1);
        }
        if (op == 2)
        {
            int x, y;
            in >> x >> y;
            upd(1, n, x, x + y - 1, 1, 1);
        }
        if (op == 3)
        {
            out << aint[1].max1 << '\n';
        }
        if (op < 3)
        {
            //out << q << '\n';
           // afis(1, n, 1);
          //  out << '\n';
        }
    }
    in.close();
    out.close();
    return 0;
}