#include <bits/stdc++.h>
#define all(cont) cont.begin(), cont.end()
#define pb push_back
#define fi first
#define se second
#define l segmTree[2 * node + 1]
#define r segmTree[2 * node + 2]

using namespace std;

typedef pair <int, int> pii;
typedef vector <int> vi;
typedef long long ll;
typedef unsigned long long ull;

ifstream f ("hotel.in");
ofstream g ("hotel.out");

const int NMAX = 1e5;

struct Node {
    int lenMax;
    int lenLeft, lenRight;
    int lazy;
} segmTree[4 * NMAX];

void recalc (int node, int left, int right) {
    int mid = left + (right - left) / 2;
    segmTree[node].lenMax = max (l.lenMax, max (r.lenMax, l.lenRight + r.lenLeft));
    segmTree[node].lenLeft = (l.lenLeft == (mid - left + 1)) ? (l.lenLeft + r.lenLeft) : (l.lenLeft);
    segmTree[node].lenRight = (r.lenRight == (right - mid)) ? (l.lenRight + r.lenRight) : (r.lenRight);
}

void build (int node, int left, int right) {
    if (left == right) {
        segmTree[node].lenMax = segmTree[node].lenLeft = segmTree[node].lenRight = 1;
        return;
    }
    int mid = left + (right - left) / 2;
    build (2 * node + 1, left, mid);
    build (2 * node + 2, mid + 1, right);
    recalc (node, left, right);
}

void propagate (int node, int left, int right) {
    if (!segmTree[node].lazy || left == right) return;
    int mid = left + (right - left) / 2;
    l.lenMax = l.lenLeft = l.lenRight = ((segmTree[node].lazy == 2) ? (0) : (mid - left + 1));
    r.lenMax = r.lenLeft = r.lenRight = ((segmTree[node].lazy == 2) ? (0) : (right - mid));
    l.lazy = r.lazy = segmTree[node].lazy;
    segmTree[node].lazy = 0;
}

void update (int node, int left, int right, int x, int y, int val) {
    propagate(node, left, right);
    if (x <= left && right <= y) {
        segmTree[node].lenMax = segmTree[node].lenLeft = segmTree[node].lenRight = ((val == 1) ? (0) : (right - left + 1));
        segmTree[node].lazy = 1 + val;
        return;
    }
    int mid = left + (right - left) / 2;
    if (x <= mid) {
        update (2 * node + 1, left, mid, x, y, val);
    }
    if (mid < y) {
        update (2 * node + 2, mid + 1, right, x, y, val);
    }
    recalc (node, left, right);
}

int main() {
    int n, q;
    f >> n >> q;
    build (0, 0, n - 1);
    while (q--) {
        int c, pos, m;
        f >> c;
        if (c == 1) {
            f >> pos >> m;
            --pos;
            update (0, 0, n - 1, pos, pos + m - 1, 1);
        } else if (c == 2) {
            f >> pos >> m;
            --pos;
            update (0, 0, n - 1, pos, pos + m - 1, 0);
        } else {
            g << segmTree[0].lenMax << '\n';
        }
    }

    f.close();
    g.close();
    return 0;
}