#include <bits/stdc++.h>
using namespace std;
ifstream fein("hotel.in");
ofstream g("hotel.out");
#define NMAX 100001
#define pii pair<int,int>

int n, q, sol;

struct node {
    int val;
    int length;
    int pref, suf;
    int flag; //0 if no changes should happen to children, 1=fill rooms, 2=clear rooms
    node() {
        val=0;
        pref=0;
        suf=0;
        length=0;
    }

    void set() {
        val=length;
        pref=length;
        suf=length;
    }
    void clear() {
        val=0;
        pref=0;
        suf=0;
    }
};

struct segment_tree {
    int p2;
    vector<node> v;

    void init() {
        p2=1;
        while(p2<n) {
            p2<<=1;
        }
        v.assign(p2*2, node());
    }

    void push(int nod) {
        assert(v[nod].flag!=0);
        if(v[nod].flag==1) {
            v[nod*2].set();
            v[nod*2+1].set();
            v[nod*2].flag=1;
            v[nod*2+1].flag=1;
        }
        else if(v[nod].flag==2) {
            v[nod*2].clear();
            v[nod*2+1].clear();
            v[nod*2].flag=2;
            v[nod*2+1].flag=2;
        }
        v[nod].flag=0;
    }

    void pull(int nod) {
        if(v[nod*2].suf==v[nod*2].length) {
            v[nod].pref=v[nod*2].length+v[nod*2+1].pref;
        }
        else {
            v[nod].pref=v[nod*2].pref;
        }
        if(v[nod*2+1].pref==v[nod*2+1].length) {
            v[nod].suf=v[nod*2+1].length+v[nod*2].suf;
        }
        else {
            v[nod].suf=v[nod*2+1].suf;
        }
        v[nod].val=max(v[nod*2].suf+v[nod*2+1].pref, max(v[nod*2].val, v[nod*2+1].val));
    }

    void build(int nod, int l , int r) {
        if(l==r) {
            v[nod].length=1;
            v[nod].set();
            v[nod].flag=0;
        }
        else {
            int mid=(l+r)/2;
            build(nod*2, l, mid);
            build(nod*2+1, mid+1, r);
            v[nod].length=v[nod*2].length+v[nod*2+1].length;
            v[nod].set();
            v[nod].flag=0;
        }

    }
    void update(int nod, int l, int r, int a, int b, int val) {
        if(a<=l && r<=b) {
            if(val==1) {
                v[nod].set();
                v[nod].flag=val;
            }
            if(val==2) {
                v[nod].clear();
                v[nod].flag=val;
            }
        }
        else {
            if(v[nod].flag) {
                push(nod);
            }

            int mid=(l+r)/2;
            if(a<=mid) {
                update(nod*2, l, mid, a, b, val);
            }
            if(b>mid) {
                update(nod*2+1, mid+1, r, a, b, val);
            }
            pull(nod);
        }
    }
} aint;

void solve() {
    for(int i=1;i<=q;i++) {
        int c;
        fein>>c;
        if(c==3) {
            sol=0;
            g<<aint.v[1].val<<'\n';
        }
        if(c==1) {
            int x, m;
            fein>>x>>m;
            aint.update(1, 1, n, x, x+m-1, 2);
        }
        if(c==2) {
            int x, m;
            fein>>x>>m;
            aint.update(1, 1, n, x, x+m-1, 1);
        }
    }
}

void read_data() {
    fein>>n>>q;
}

int main()
{
    read_data();
    aint.init();
    aint.build(1, 1, n);
    solve();
    return 0;
}