#include <fstream>
#include <vector>

using namespace std;

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

struct SegTreeNode {
    int prefix;
    int suffix;
    int answer;
    int length;
    int lazy; // 0 fac nimic, -1 setez la 0, iar 1 fac 1

    SegTreeNode()
        : prefix(0), suffix(0), answer(0), length(0), lazy(0) {}

    SegTreeNode(int prefix, int suffix, int answer, int length, int lazy)
        : prefix(prefix), suffix(suffix), answer(answer), length(length), lazy(lazy) {}

    SegTreeNode(const SegTreeNode& left, const SegTreeNode& right) {
        this->length = left.length + right.length;
        this->prefix = (left.prefix == left.length) ? left.prefix + right.prefix : left.prefix;
        this->suffix = (right.suffix == right.length) ? right.suffix + left.suffix : right.suffix;
        this->answer = max(max(left.answer, right.answer), left.suffix + right.prefix);
        this->lazy = 0;
    }
};

vector<SegTreeNode> segTree;

void build(int node, int left, int right) {
    if (left == right) {
        segTree[node] = SegTreeNode(1, 1, 1, 1, 1);
        return;
    }

    int mid = (left + right) / 2;

    build(2 * node, left, mid);
    build(2 * node + 1, mid + 1, right);

    segTree[node] = SegTreeNode(segTree[2 * node], segTree[2 * node + 1]);
}

void lazyUpdate(int node, int left, int right) {
    if (segTree[node].lazy == 0) return;

    if (segTree[node].lazy == 1)
        segTree[node].prefix = segTree[node].suffix = segTree[node].answer = right - left + 1;
    else
        segTree[node].prefix = segTree[node].suffix = segTree[node].answer = 0;

    if (left != right)
        segTree[2 * node].lazy = segTree[2 * node + 1].lazy = segTree[node].lazy;

    segTree[node].lazy = 0;
}

void update(int node, int left, int right, int a, int b, int lazyVal) {
    if (left > b || right < a)
        return;

    if (left >= a && right <= b) {
        segTree[node].lazy = lazyVal;
        if (left == right) lazyUpdate(node, left, right);
        return;
    }

    lazyUpdate(node, left, right);
    int mid = (left + right) / 2;

    update(2 * node, left, mid, a, b, lazyVal);
    update(2 * node + 1, mid + 1, right, a, b, lazyVal);

    lazyUpdate(2 * node, left, mid);
    lazyUpdate(2 * node + 1, mid + 1, right);

    segTree[node] = SegTreeNode(segTree[2 * node], segTree[2 * node + 1]);
}

int main() {
    int n, m;
    fin >> n >> m;

    segTree.resize(4 * n + 1);
    build(1, 1, n);

    while (m--) {
        int q;
        fin >> q;

        if (q == 1) {
            int i, length;
            fin >> i >> length;
            update(1, 1, n, i, i + length - 1, -1);
        } else if (q == 2) {
            int i, length;
            fin >> i >> length;
            update(1, 1, n, i, i + length - 1, 1);
        } else {
            fout << segTree[1].answer << '\n';
        }
    }

    return 0;
}