#include <iostream>
#include <fstream>
#include <algorithm>

const int64_t minim = -1e18;
const int ocupat = -100005;
using namespace std;

class nod{
public:
    int s;  //suma elementelor
    int l; //secv s max care incepe la stanga
    int r; //secv s max care se termina la dreapta
    int m; //secv s max care este continuta in interval
    int lazy = 0;
};
nod ST[400020];

int N, P;
int M;
int ql, qr;
///void update(int st, int dr, int cur, int x, int pos)
void update(int st, int dr, int cur, int x, int il, int ir)
{
    if(ir<st || il>dr)
        return;
    if(il <= st && dr <= ir)
    {
        if(x == 1)
        {
            ST[cur].s =(dr - st + 1);
            ST[cur].l =(dr - st + 1);
            ST[cur].r =(dr - st + 1);
            ST[cur].m =(dr - st + 1);
            ST[cur].lazy = x;
        }
        else
        {
            ST[cur].s = ocupat;
            ST[cur].l = ocupat;
            ST[cur].r = ocupat;
            ST[cur].m = ocupat;
            ST[cur].lazy = ocupat;
        }
        return;
    }
    int mij = (st + dr)/2;  //divide
    int ls = 2 * cur;
    int rs = (2 * cur) | 1;
    if(ST[cur].lazy)    //avem update amanat
    {
        if(ST[cur].lazy == 1)
        {
        ST[ls].s =(mij - st + 1);
        ST[ls].l =(mij - st + 1);
        ST[ls].r =(mij - st + 1);
        ST[ls].m =(mij - st + 1);
        ST[ls].lazy = ST[cur].lazy;

        ST[rs].s =(dr - mij);
        ST[rs].l =(dr - mij);
        ST[rs].r =(dr - mij);
        ST[rs].m =(dr - mij);
        ST[rs].lazy = ST[cur].lazy;
        }
        else
            {
        ST[ls].s = ocupat;
        ST[ls].l = ocupat;
        ST[ls].r = ocupat;
        ST[ls].m = ocupat;
        ST[ls].lazy = ST[cur].lazy;

        ST[rs].s = ocupat;
        ST[rs].l = ocupat;
        ST[rs].r = ocupat;
        ST[rs].m = ocupat;
        ST[rs].lazy = ST[cur].lazy;
        }
        ST[cur].lazy = 0;
    }
        update(st, mij, ls, x, il, ir);
        update(mij+1 ,dr ,rs, x, il, ir);

    //etapa combina
    ST[cur].s = ST[ls].s + ST[rs].s;
    ST[cur].l = max(ST[ls].l, ST[ls].s + ST[rs].l);
    ST[cur].r = max(ST[rs].r, ST[rs].s + ST[ls].r);
    ST[cur].m = max(max(ST[ls].m, ST[rs].m), ST[ls].r + ST[rs].l);
}

int main()
{
    int c, M, ceva;
    ifstream in ("hotel.in");
    ofstream out ("hotel.out");
    /*for (int i = 0; i < 1000000; ++i)
    {
        cout<<i*ocupat<<"\n";
        if (i*ocupat > 0)
        {
            cout<<i<<"\n";
            break;
        }
    }*/
    in>>N>>P;
    //for(int i = 1; i <= N; ++i)
        update(1, N, 1, 1, 1, N);  //marcam camerele ca fiind libere
    for(int i = 1; i <= P; ++i)
    {
        in>>c;
        switch (c)
            {
            case 1:
                in>>ceva>>M;
                //for(int i = 0; i < M; ++i)
                    update(1, N, 1, ocupat, ceva, ceva + M - 1);
                //cout<<ST[1].m<<"\n";
                break;
            case 2:
                in>>ceva>>M;
                //for(int i = 0; i < M; ++i)
                    update(1, N, 1, 1, ceva, ceva + M - 1);
                //cout<<ST[1].m<<"\n";
                break;
            case 3:
                if(ST[1].m<0)
                    out<<"0\n";
                else
                    out<<ST[1].m<<"\n";
                break;
            }
    }
}