#include <bits/stdc++.h>
#define ll long long

using namespace std;

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

const int NMAX = 1e5;

int n, q;

struct TreeNode {
    int max_subsecv_len;
    int max_prefix_len;
    int max_suffix_len;
    bool is_full;

    TreeNode() : max_subsecv_len(0), max_prefix_len(0), max_suffix_len(0), is_full(0) {}
    TreeNode(int x) {
        max_subsecv_len = max_prefix_len = max_suffix_len = is_full = !x;
    }
};

struct AINT {
    TreeNode aint[4 * NMAX + 1];
    int lazy[4 * NMAX + 1];

    TreeNode update_node(TreeNode left, TreeNode right) {
        TreeNode answer;
        answer.max_subsecv_len = max({left.max_subsecv_len, right.max_subsecv_len, left.max_suffix_len + right.max_prefix_len});
        answer.max_prefix_len = left.max_prefix_len + (left.is_full ? right.max_prefix_len : 0);
        answer.max_suffix_len = right.max_suffix_len + (right.is_full ? left.max_suffix_len : 0);
        answer.is_full = left.is_full & right.is_full;
        return answer;
    }

    void apply_lazy(int node, int left, int right, int p_lazy) {
        if(p_lazy == -1) {
            return;
        }
        aint[node].is_full = aint[node].max_prefix_len = aint[node].max_suffix_len = aint[node].max_subsecv_len = (p_lazy ? 0 : right - left + 1);
        lazy[node] = p_lazy;
    }

    void push_lazy(int node, int left, int right) {
        int mid = (left + right) / 2;
        apply_lazy(node * 2, left, mid, lazy[node]);
        apply_lazy(node * 2 + 1, mid + 1, right, lazy[node]);
        lazy[node] = -1;
    }

    void build(int node, int left, int right) {
        lazy[node] = -1;
        if(left == right) {
            aint[node] = TreeNode(0);
            return;
        }
        int mid = (left + right) / 2;
        build(node * 2, left, mid);
        build(node * 2 + 1 , mid + 1, right);
        aint[node] = update_node(aint[node * 2], aint[node * 2 + 1]);
    }

    void update(int node, int left, int right, int uleft, int uright, int value) {
        if(left > uright || right < uleft) {
            return;
        }
        if(left >= uleft && right <= uright) {
            apply_lazy(node, left, right, value);
            return;
        }
        push_lazy(node, left, right);
        int mid = (left + right) / 2;
        update(node * 2, left, mid, uleft, uright, value);
        update(node * 2 + 1, mid + 1, right, uleft, uright, value);
        aint[node] = update_node(aint[node * 2], aint[node * 2 + 1]);
    }
}aint;

int main() {
    fin >> n >> q;

    aint.build(1, 1, n);
    while(q--) {
        int type;
        fin >> type;
        if(type == 1) {
            int x, y;
            fin >> x >> y;
            aint.update(1, 1, n, x, x + y - 1, 1);
        }
        else if(type == 2) {
            int x, y;
            fin >> x >> y;
            aint.update(1, 1, n, x, x + y - 1, 0);
        }
        else {
            fout << aint.aint[1].max_subsecv_len << '\n';
        }
    }
    return 0;
}