#include <bits/stdc++.h>
#define maxn 100005

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

int max3 (int a, int b, int c){
    int max = a;
    if (max < b) max = b;
    if (max < c) max = c;
    return max;
}

struct Node{
    int lenMax, lenLeft, lenRight, len;
};

struct Node tree[4*maxn];

void buildTree (int node, int left, int right){
    if (left == right){
        tree[node].lenMax = 1;
        tree[node].lenLeft = 1;
        tree[node].lenRight = 1;
        tree[node].len = 1;
        return;
    }
    int mid = (left + right) / 2;
    buildTree (2*node+1, left, mid);
    buildTree (2*node+2, mid+1, right);

    tree[node].lenMax = right - left + 1;
    tree[node].lenLeft = right - left + 1;
    tree[node].lenRight = right - left + 1;
    tree[node].len = right - left + 1;
}

int lazy[4*maxn];

void update (int node, int left, int right, int l, int r, int type){
    int val;
    if (lazy[node]){
        if (lazy[node] < 0)
            val = 0;
        else if (lazy[node] > 0)
            val = right - left + 1;

        tree[node].lenMax = val;
        tree[node].lenLeft = val;
        tree[node].lenRight = val;

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

        lazy[node] = 0;
    }

    if (left > right or left > r or right < l)
        return;

    if (l <= left and right <= r){
        val = 0;
        if (type == 1)
            val = right - left + 1;

        tree[node].lenMax = val;
        tree[node].lenLeft = val;
        tree[node].lenRight = val;

        if (left < right){
            lazy[2*node+1] += type;
            lazy[2*node+2] += type;
        }

        return;
    }

    int mid = (left + right) / 2;
    update (2*node+1, left, mid, l, r, type);
    update (2*node+2, mid+1, right, l, r, type);

    tree[node].lenMax = max3 (tree[2*node+1].lenMax, tree[2*node+2].lenMax, tree[2*node+1].lenRight + tree[2*node+2].lenLeft);

    if (tree[2*node+1].lenLeft == tree[2*node+1].len) tree[node].lenLeft = tree[2*node+1].lenLeft + tree[2*node+2].lenLeft;
    else                                             tree[node].lenLeft = tree[2*node+1].lenLeft;

    if (tree[2*node+2].lenRight == tree[2*node+2].len) tree[node].lenRight = tree[2*node+2].lenRight + tree[2*node+1].lenRight;
    else                                              tree[node].lenRight = tree[2*node+2].lenRight;
}

int main()
{
    int n, Q, i;
    fin >> n >> Q;

    buildTree (0, 0, n-1);

    while (Q --){
        int type, left, right, len, val;
        fin >> type;
        if (type == 3){
            fout << tree[0].lenMax << '\n';
        }
        else{
            fin >> left >> len;
            right = left + len - 1;
            left --; right --;
            val = (-1) * (type == 1) + (1) * (type == 2);
            update (0, 0, n-1, left, right, val);
        }
    }
    return 0;
}