#include <bits/stdc++.h>

using namespace std;

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

struct SegTree{
    int next_power_of_2(int n)
    {
        int p=1;
        while(p<=n) p*=2;
        return p;
    }

    int offset;
    vector<int> maxinterval,maxdr,maxst;
    vector<int> aint, lazy;

    SegTree(int n)
    {
        offset = next_power_of_2(n+1);
        maxinterval.resize(2*offset + 1);
        maxdr.resize(2*offset + 1);
        maxst.resize(2*offset + 1);
        aint.resize(2*offset + 1);
        lazy.resize(2*offset + 1);
        update(0,offset-1,1);
    }

    void push_lazy(int node, int l, int r)
    {
        if(node <= offset && lazy[node]!=0)
        {
            lazy[2*node] = lazy[node];
            lazy[2*node + 1] = lazy[node];
        }
        int length = (r-l+1);
        if(lazy[node] == -1)
        {
            maxinterval[node] = length;
            maxdr[node] = length;
            maxst[node] = length;
        }
        else if(lazy[node] == 1)
        {
            maxinterval[node] = 0;
            maxdr[node] = 0;
            maxst[node] = 0;
        }
        lazy[node] = 0;
    }

    void _update(int node, int l, int r, int gl, int gr, int ch)
    {
        push_lazy(node,l,r);

        //cerr<<l<<" "<<r<<" "<<gl<<" "<<gl <<"\n";
        if(r < gl || gr < l) return;

        //cerr<<l+1<<" "<<r+1<<"\n";

        if(gl <= l && r <= gr)
        {
            lazy[node] = ch;
            push_lazy(node,l,r);
            return;
        }
        //if(node >= offset) return;
        int mij = (l+r)/2;
        _update(2*node    ,l     ,mij,gl, gr, ch);
        _update(2*node + 1, mij+1, r, gl, gr, ch);

        maxinterval[node] = max(maxinterval[2*node],maxinterval[2*node+1]);
        maxinterval[node] = max(maxinterval[node], maxdr[2*node] + maxst[2*node + 1]);

        maxdr[node] = maxdr[2*node + 1];
        if(maxdr[node] == r - mij) ///e gol
        {
            //cout<<"brok";
            maxdr[node] = maxdr[2*node] + r-mij;
        }

        maxst[node] = maxst[2*node];
        if(maxst[node] == mij-l+1) ///e gol
        {
            maxst[node] = maxst[2*node+1] + mij-l+1;
        }
    }

    void update(int l, int r, int ch)
    {
        _update(1,0,offset - 1, l,r,ch);
    }
};

int main()
{
    int n,p; fin>>n>>p;
    SegTree st = SegTree(n);
    st.update(0,n-1,-1);
    for(int i=0; i<p; i++)
    {
        int type; fin>>type;
        if(type == 1)
        {
            int l,nr; fin>>l>>nr;
            //cerr<<"updatez 1\n";
            st.update(l-1,l+nr-2,1); ///vin
        }
        else if(type == 2)
        {
            int l,nr; fin>>l>>nr;
            //cerr<<"updatez -1\n";
            st.update(l-1,l+nr-2,-1); ///pleaca
        }
        else
        {
            int rasp = st.maxinterval[1];
            fout<<rasp<<"\n";
        }
    }
    return 0;
}