#include <fstream>

using namespace std;

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

int val, L, R, maxi;

struct arb
{
    int val, lazy, l_s, l_d, l_max;
};

const int NMAX = 100001;

arb a[NMAX];

int v_camera[NMAX];

void update(int nod, int left, int right)
{
    a[nod].l_max = 0;
    if (a[nod].lazy)
    {
        if (left == right)
        {
            a[nod].val += a[nod].lazy;
            v_camera[left] = a[nod].val;
        }
        else
        {
            a[2 * nod].lazy += a[nod].lazy;
            a[2 * nod + 1].lazy += a[nod].lazy;
        }
        a[nod].lazy = 0;
    }

    if (left > right || left > R || right < L)
        return;

    if (L <= left && right <= R)
    {
        if (left == right)
        {
            a[nod].val += val;
            v_camera[left] = a[nod].val;
        }
        else
        {
            a[2 * nod].lazy += val;
            a[2 * nod + 1].lazy += val;
        }
        return;
    }

    int m = (left + right) / 2;

    update(2 * nod, left, m);
    update(2 * nod + 1, m + 1, right);
}

void query(int nod, int left, int right)
{
    a[nod].l_max = 0;
    if (a[nod].lazy)
    {
        if (left == right)
        {
            a[nod].val += a[nod].lazy;
            v_camera[left] = a[nod].val;
        }
        else
        {
            a[2 * nod].lazy += a[nod].lazy;
            a[2 * nod + 1].lazy += a[nod].lazy;
        }

        a[nod].lazy = 0;
    }

    if (left > right)
        return;

    if (left == right)
    {
        int v = a[nod].val == 0;
        a[nod].l_s = v;
        a[nod].l_d = v;
        a[nod].l_max = v;
        return;
    }

    int m = (left + right) / 2;

    query(2 * nod, left, m);
    query(2 * nod + 1, m + 1, right);

    a[nod].l_s = a[2 * nod].l_s;
    a[nod].l_d = a[2 * nod + 1].l_d;

    if (a[2 * nod].l_s == a[2 * nod].l_d  && a[2 * nod].l_d == m - left + 1)
        a[nod].l_s  += a[2 * nod + 1].l_s;

    if (a[1 + 2 * nod].l_s == a[2 * nod + 1].l_d && a[2 * nod + 1].l_d == right - m)
        a[nod].l_d += a[2 * nod].l_d;

    a[nod].l_max = max(max(a[2 * nod].l_max, a[2 * nod + 1].l_max), max(max(a[nod].l_s, a[nod].l_d),a[2 * nod + 1].l_s + a[2 * nod].l_d));
}

int n, p, q, i, m;

int main()
{
    fin >> n >> p;
    while (p--)
    {
        fin >> q;
        if (q == 3)
        {
            maxi = 0;

            val = 0;

            query(1, 1, n);

            fout << a[1].l_max << "\n";
        }
        else
        {
            fin >> L >> R;
            val = R;
            if (q == 2) val = -v_camera[L];
            R = L + R - 1;
            update(1, 1, n);
        }
    }
    return 0;
}