#include <iostream>
#include <fstream>

using namespace std;
ifstream in("hotel.in");
ofstream out("hotel.out");

#define ll long long
#define ull unsigned long long
#define pb push_back
const int NMax = 1e5 + 5;
const int arbMax = 3e5 + 5;

int N,M;
int lazy[arbMax];
struct elem {
    int free=0,st=0,dr=0;
}arb[arbMax];

void update(int,int,int,int,int,int);

int main() {
    in>>N>>M;

    update(1,1,N,1,N,-1);
    while (M--) {
        int tip,a,b;
        in>>tip;
        if (tip == 3) {
            out<<arb[1].free<<'\n';
        }
        else {
            in>>a>>b;
            b = a+b-1;
            tip = (tip == 1) ? 1 : -1;
            update(1,1,N,a,b,tip);
        }
    }

    in.close();out.close();
    return 0;
}

void update(int node,int st,int dr,int a,int b,int act) {
    int fs = node<<1,ss = fs + 1;

    if (lazy[node] != 0) {
        if (lazy[node] == 1) {
            arb[node].free = arb[node].st = arb[node].dr = 0;
        }
        else {
            arb[node].free = arb[node].st = arb[node].dr = (dr-st+1);
        }

        if (st != dr) {
            lazy[fs] = lazy[ss] = lazy[node];
        }
        lazy[node] = 0;
    }

    if (dr < a || b < st) {
        return;
    }

    if (a <= st && dr <= b) {
        int lz;
        if (act == 1) {
            arb[node].free = arb[node].st = arb[node].dr = 0;
            lz = 1;
        }
        else {
            arb[node].free = arb[node].st = arb[node].dr = (dr-st+1);
            lz = -1;
        }

        if (st != dr) {
            lazy[fs] = lazy[ss] = lz;
        }
        return;
    }

    int mij = (st+dr)>>1;
    update(fs,st,mij,a,b,act);
    update(ss,mij+1,dr,a,b,act);

    arb[node].st = arb[fs].st + ((arb[fs].free == mij-st+1) ? arb[ss].st : 0);
    arb[node].dr = arb[ss].dr + ((arb[ss].free == dr-(mij+1)+1) ? arb[fs].dr : 0);
    arb[node].free = max(arb[fs].dr+arb[ss].st,max(arb[fs].free,arb[ss].free));
}