#include <iostream>
#include <iomanip>
#include <fstream>

#include <algorithm>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#if __cplusplus > 199711L
#include <unordered_map>
#include <unordered_set>
#endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstring>
#include <cstdlib>

#define st first
#define nd second

using namespace std;

typedef long long int64;

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

const int NMAX = 100010, inf = 0x3f3f3f3f;

int N, Q, i, m, c;
int tree[4 * NMAX], lazy[4 * NMAX];

class SegmentTree {

public:
    SegmentTree() {};

    void update(const int node, const int left, const int right, const int qleft, const int qright, const int value) {
        if (lazy[node]) {
            tree[node] = (lazy[node] - 1) * (right - left + 1);
            if (left != right) {
                lazy[node * 2] = lazy[node];
                lazy[node * 2 + 1] = lazy[node];
            }
            lazy[node] = 0;
        }

        if (left > right || left > qright || right < qleft) return;

        if (left >= qleft && right <= qright) {
            tree[node] = (value - 1) * (right - left + 1);
            if (left != right) {
                lazy[node * 2] = value;
                lazy[node * 2 + 1] = value;
            }
            return;
        }

        int div = (left + right) >> 1;
        update(node * 2, left, div, qleft, qright, value);
        update(node * 2 + 1, div + 1, right, qleft, qright, value);

        tree[node] = tree[node * 2] + tree[node * 2 + 1];
    }

    pair<int, int> query(const int node, const int left, const int right) {
        if (lazy[node]) {
            tree[node] = (lazy[node] - 1) * (right - left + 1);
            if (left != right) {
                lazy[node * 2] = lazy[node];
                lazy[node * 2 + 1] = lazy[node];
            }
            lazy[node] = 0;
        }

        if (tree[node] == 0) return make_pair(left, right);
        if (tree[node] == right - left + 1) return make_pair(inf + 1, inf);

        pair<int, int> x, y;
        int div = (left + right) >> 1;
        x = query(node * 2, left, div);
        y = query(node * 2 + 1, div + 1, right);

        if (x.nd + 1 == y.st) return make_pair(x.st, y.nd);
        if (x.nd - x.st > y.nd - y.st) return x;
        return y;
    }
} Tree;

int main() {
    Tree = SegmentTree();
    fin >> N >> Q;
    while(Q--) {
        fin >> c;
        if (c == 1) {
            fin >> i >> m;
            Tree.update(1, 1, N, i, i + m - 1, 2);
        }
        else if (c == 2) {
            fin >> i >> m;
            Tree.update(1, 1, N, i, i + m - 1, 1);
        }
        else {
            pair<int, int> res;
            res = Tree.query(1, 1, N);
            if (res.st == inf + 1) fout << "0\n";
            else fout << res.nd - res.st + 1 << '\n';
        }
    }

    fin.close();
    fout.close();
    return 0;
}