#include <fstream>
///CU PARSAREA CITIRII
using namespace std;
 
class InParser
{
private:
    FILE *fin;
    char *buff;
    int sp;
    char read_ch()
    {
        ++sp;
        if (sp == 4096)
        {
            sp = 0;
            fread(buff, 1, 4096, fin);
        }
        return buff[sp];
    }
public:
    InParser(const char *nume)
    {
        fin = fopen(nume, "r");
        buff = new char[4096]();
        sp = 4095;
    }
    InParser & operator >>(int &n)
    {
        char c;
        while(!isdigit(c = read_ch()));
 
        n = c - '0';
        while(isdigit(c = read_ch()))
            n = n * 10 + c - '0';
        return *this;
    }
};
 
InParser fin("hotel.in");
ofstream fout("hotel.out");
 
int val, L, R, maxi, v, q;
 
struct arb
{
    int lazy, l_s, l_d, l_max;
};
 
const int NMAX = 100001;
 
arb a[4 * NMAX];
 
void build(int nod, int left, int right)
{
    if (left == right)
    {
        a[nod].l_s = a[nod].l_d = a[nod].l_max = 1;
        return;
    }
 
    int m = (left + right) / 2;
 
    build(2 * nod, left, m);
    build(2 * nod + 1, m + 1, right);
 
    a[nod].l_s = a[nod].l_d = a[nod].l_max = right - left + 1;
}
 
void update(int nod, int left, int right)
{
    if (a[nod].lazy == 1)
    {
        a[nod].l_s = a[nod].l_d = a[nod].l_max = 0;
        a[nod].lazy = -1;
        if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 1;
    }
    else if (a[nod].lazy == 0)
    {
        a[nod].l_s = a[nod].l_d = a[nod].l_max = right - left + 1;
        a[nod].lazy = -1;
        if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 0;
    }
    if (left > R || right < L)
        return;
 
    if (L <= left && right <= R)
    {
        if (q == 1)
        {
            a[nod].l_d = a[nod].l_s = a[nod].l_max = 0;
            if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 1;
        }
        else
        {
            a[nod].l_d = a[nod].l_s = a[nod].l_max = right - left + 1;
            if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 0;
        }
        return;
    }
 
    int m = (left + right) / 2;
 
    update(2 * nod, left, m);
    update(2 * nod + 1, m + 1, right);
 
    a[nod].l_max = max(max(a[2 * nod].l_max, a[2 * nod + 1].l_max), a[2 * nod].l_d + a[2 * nod + 1].l_s);
    a[nod].l_s = (a[2 * nod].l_max == m - left + 1)? a[2 * nod].l_max + a[2 * nod + 1].l_s : a[2 * nod].l_s;
    a[nod].l_d = (a[2 * nod + 1].l_max == right - m)? a[2 * nod + 1].l_max + a[2 * nod].l_d : a[2 * nod + 1].l_d;
 
}
int n, p, i, m;
 
int main()
{
    fin >> n >> p;
 
    build(1, 1, n);
 
    while (p--)
    {
        fin >> q;
        if (q == 3)
            fout << a[1].l_max << "\n";
        else
        {
            fin >> L >> R;
 
            R = L + R - 1;
 
            update(1, 1, n);
        }
    }
    return 0;
}
 
///FARA PARSAREA CITIRII
/*#include <fstream>
{1}
using namespace std;
{1}
ifstream fin("hotel.in");
ofstream fout("hotel.out");
{1}
int val, L, R, maxi, v, q;
{1}
struct arb
{
    int lazy, l_s, l_d, l_max;
};
{1}
const int NMAX = 100001;
{1}
arb a[4 * NMAX];
{1}
void build(int nod, int left, int right)
{
    if (left == right)
    {
        a[nod].l_s = a[nod].l_d = a[nod].l_max = 1;
        return;
    }
{1}
    int m = (left + right) / 2;
{1}
    build(2 * nod, left, m);
    build(2 * nod + 1, m + 1, right);
{1}
    a[nod].l_s = a[nod].l_d = a[nod].l_max = right - left + 1;
}
{1}
void update(int nod, int left, int right)
{
    if (a[nod].lazy == 1)
    {
        a[nod].l_s = a[nod].l_d = a[nod].l_max = 0;
        a[nod].lazy = -1;
        if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 1;
    }
    else if (a[nod].lazy == 0)
    {
        a[nod].l_s = a[nod].l_d = a[nod].l_max = right - left + 1;
        a[nod].lazy = -1;
        if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 0;
    }
    if (left > R || right < L)
        return;
{1}
    if (L <= left && right <= R)
    {
        if (q == 1)
        {
            a[nod].l_d = a[nod].l_s = a[nod].l_max = 0;
            if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 1;
        }
        else
        {
            a[nod].l_d = a[nod].l_s = a[nod].l_max = right - left + 1;
            if (left != right) a[2 * nod].lazy = a[2 * nod + 1].lazy = 0;
        }
        return;
    }
{1}
    int m = (left + right) / 2;
{1}
    update(2 * nod, left, m);
    update(2 * nod + 1, m + 1, right);
{1}
    a[nod].l_max = max(max(a[2 * nod].l_max, a[2 * nod + 1].l_max), a[2 * nod].l_d + a[2 * nod + 1].l_s);
    a[nod].l_s = (a[2 * nod].l_max == m - left + 1)? a[2 * nod].l_max + a[2 * nod + 1].l_s : a[2 * nod].l_s;
    a[nod].l_d = (a[2 * nod + 1].l_max == right - m)? a[2 * nod + 1].l_max + a[2 * nod].l_d : a[2 * nod + 1].l_d;
{1}
}
int n, p, i, m;
{1}
int main()
{
    fin >> n >> p;
{1}
    build(1, 1, n);
{1}
    while (p--)
    {
        fin >> q;
        if (q == 3)
            fout << a[1].l_max << "\n";
        else
        {
            fin >> L >> R;
{1}
            R = L + R - 1;
{1}
            update(1, 1, n);
        }
    }
    return 0;
}
*/