#include <cstdio>
#include <cctype>
#include <algorithm>

#define NMAX 100000 //o suta de mii

#define BUF_SIZE 1 << 17

using namespace std;

FILE *fin = fopen("hotel.in", "r");
FILE *fout = fopen("hotel.out", "w");

char buf[BUF_SIZE];
int pos = BUF_SIZE;

inline char nextch(){
    if(pos == BUF_SIZE){
        fread(buf, BUF_SIZE, 1, fin);
        pos = 0;
    }

    return buf[pos++];
}

inline int read(){
    char ch = nextch();

    while( !isdigit(ch) ){
        ch = nextch();
    }

    int nr = 0;
    while( isdigit(ch) ){
        nr = nr * 10 + ch - '0';
        ch = nextch();
    }

    return nr;
}

struct element{
    int dimLeft;
    int dimRight;
    int dimInd;
};

int N, P;
int A, B;
int valUpdate;
element tree[4 * NMAX + 1];
int lazy[4 * NMAX + 1];

element rezultant(element X, element Y, int dim1, int dim2){
    element rez;

    if(X.dimLeft == dim1){
        rez.dimLeft = X.dimLeft + Y.dimLeft;
    }
    else {
        rez.dimLeft = X.dimLeft;
    }

    if(Y.dimRight == dim2){
        rez.dimRight = Y.dimRight + X.dimRight;
    }
    else {
        rez.dimRight = Y.dimRight;
    }

    rez.dimInd = max(X.dimInd, Y.dimInd);
    rez.dimInd = max(rez.dimInd, X.dimRight + Y.dimLeft);

    return rez;
}

inline void propagareLazy (int node, int left, int right){
    if(lazy[node] != 0){
        //daca nodul in care am ajuns nu este inca actualizat, il actualizez si propag lazy-ul la fii

        if(lazy[node] == 1){
            tree[node].dimLeft = tree[node].dimInd = tree[node].dimRight = 0;
        }
        else if(lazy[node] == 2){
            tree[node].dimLeft = tree[node].dimInd = tree[node].dimRight = right - left + 1;
        }

        if(node * 2 <= 4 * N){
            lazy[node * 2] = lazy[node];
        }
        if(node * 2 + 1 <= 4 * N){
            lazy[node * 2 + 1] = lazy[node];
        }

        lazy[node] = 0; //adica acum nu mai are lazy nodul asta
    }

}

void update(int node, int left, int right){
    if(A <= left && right <= B){
        lazy[node] = valUpdate;
        return;
    }

    propagareLazy(node, left, right);

    int mid = left + (right - left) / 2;
    if(A <= mid){
        //si fiul din stanga e relevant
        update(node * 2, left, mid);
    }
    if(B > mid){
        //si fiul din dreapta e relevant
        update(node * 2 + 1, mid + 1, right);
    }

    propagareLazy(node * 2, left, mid);
    propagareLazy(node * 2 + 1, mid + 1, right);
    tree[node] = rezultant(tree[node * 2], tree[node * 2 + 1], mid - left + 1, right - mid);
}

void buildArbore(int node, int left, int right){
    tree[node].dimLeft = tree[node].dimInd = tree[node].dimRight = right - left + 1;

    if(left == right){
        return;
    }

    int mid = left + (right - left) / 2;
    buildArbore(node * 2, left, mid);
    buildArbore(node * 2 + 1, mid + 1, right);
}

int main()
{
    N = read();
    P = read();

    buildArbore(1, 1, N);

    for(int q = 1; q <= P; q++){
        int tip;
        tip = read();

        if(tip == 1 || tip == 2){
            int i, M;
            i = read();
            M = read();

            //globale:
            A = i;
            B = i + M - 1;

            valUpdate = tip; //1 daca tip == 1 si 2 daca tip == 2
            update(1, 1, N);
        }
        else {
            //query
            propagareLazy(1, 1, N);
            fprintf(fout, "%d\n", tree[1].dimInd);
        }
    }

    return 0;
}