#include <bits/stdc++.h>

using namespace std;

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

void usain_bolt()
{
    ios::sync_with_stdio(false);
    fout.tie(0);
}

const int N = 1e5 + 5;

struct solve
{
    int mx_left, mx_right, mx;
} tree[N * 4];

int a[N], lazy[N];

void build(int left, int right, int node)
{
    if(left > right) {
        return ;
    }
    if(left == right) {
        tree[node].mx = 1;
        tree[node].mx_left = 1;
        tree[node].mx_right = 1;
        return ;
    }
    int mid = (left + right) >> 1;
    build(left, mid, node * 2);
    build(mid + 1, right, node * 2 + 1);
    tree[node].mx = right - left + 1;
    tree[node].mx_left = right - left + 1;
    tree[node].mx_right = right - left + 1;
}

void update(int left, int right, int node, int x, int y, int val)
{
    if(lazy[node] != 0) {
        tree[node].mx_left += (right - left + 1) * lazy[node];
        tree[node].mx_right += (right - left + 1) * lazy[node];
        tree[node].mx = tree[node].mx_left;
        if(left != right) {
            lazy[node * 2] += lazy[node];
            lazy[node * 2 + 1] += lazy[node];
        }
        lazy[node] = 0;
    }
    if(left > right || left > y || right < x) return ;
    if(left >= x && right <= y) {
        tree[node].mx_left += (right - left + 1) * val;
        tree[node].mx_right += (right - left + 1) * val;
        tree[node].mx = tree[node].mx_left;
        if(left != right) {
            lazy[node * 2] += val;
            lazy[node * 2 + 1] += val;
        }
        return ;
    }
    int mid = (left + right) >> 1;
    update(left, mid, node * 2, x, y, val);
    update(mid + 1, right, node * 2 + 1, x, y, val);
    if(tree[node * 2].mx_left == mid - left + 1) tree[node].mx_left = tree[node * 2].mx_left + tree[node * 2 + 1].mx_left;
    else tree[node].mx_left = tree[node * 2].mx_left;
    if(tree[node * 2 + 1].mx_right == right - mid) tree[node].mx_right = tree[node * 2 + 1].mx_right + tree[node * 2].mx_right;
    else tree[node].mx_right = tree[node * 2 + 1].mx_right;
    tree[node].mx = max(max(tree[node * 2].mx, tree[node * 2 + 1].mx), tree[node * 2].mx_right + tree[node * 2 + 1].mx_left);
}


int query(int left, int right, int node, int x, int y)
{
    if(left > right || left > y || right < x) return 0;
    if(lazy[node] != 0) {
        tree[node].mx_left += (right - left + 1) * lazy[node];
        tree[node].mx_right += (right - left + 1) * lazy[node];
        tree[node].mx = tree[node].mx_left;
        if(left != right) {
            lazy[node * 2] += lazy[node];
            lazy[node * 2 + 1] += lazy[node];
        }
        lazy[node] = 0;
    }
    int mid = (left + right) >> 1;
    if(left >= x && right <= y) return tree[node].mx;
    int ans1 = query(left, mid, node * 2, x, y);
    int ans2 = query(mid + 1, right, node * 2 + 1, x, y);

    return max(ans1, ans2);
}

int main()
{
    usain_bolt();

    int n, q;

    fin >> n >> q;
    build(1, n, 1);
    for(; q; --q) {
        int type, x, y;

        fin >> type;
        if(type == 3) {
            fout << query(1, n, 1, 1, n);
        }
        else if(type == 1) {
            fin >> x >> y;
            update(1, n, 1, x, x + y - 1, -1);
        }
        else if(type == 2) {
            fin >> x >> y;
            update(1, n, 1, x, x + y - 1, 1);
        }
    }
    return 0;
}