#include <iostream>
#include <fstream>
using namespace std;

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

const int maxN = 4e5 + 5;

struct arbore {
    int pref, suf, best;
} arb[maxN];
bool marked[maxN];
bool tip[maxN];

void push(int v) {
    if(marked[v]) {
        arb[v*2] = {0, 0, 0};
        arb[v*2+1] = {0, 0, 0};
        marked[v*2] = marked[v*2+1] = true;
        marked[v] = false;
    }
}

void combine (int node, int l1, int l2) {
    int fiu1 = node*2, fiu2 = node*2+1;
    arb[node].pref = arb[fiu1].pref;

    if(arb[fiu1].pref == l1)
      arb[node].pref += arb[fiu2].pref;

    arb[node].suf = arb[fiu2].suf;
    if(arb[fiu2].suf == l2)
      arb[node].suf += arb[fiu1].suf;
    arb[node].best = max(max(arb[fiu2].best, arb[fiu2].best), arb[fiu1].suf + arb[fiu2].pref);
}

void build (int node, int st, int dr) {
    if(st > dr) return ;
    if(st == dr) {
        arb[node].suf = arb[node].pref = dr-st+1;
        arb[node].best = dr-st+1;
    } else {
        int mij = (st + dr) / 2;

        build(node * 2, st, mij);
        build(node * 2 + 1, mij+1, dr);
        tip[node*2] = false;
        tip[node*2+1] = true;
        combine(node, mij-st+1, dr-mij);
    }
}

void update(int k, int st, int dr, int l, int r, int new_val) {
    if(l > r) return;
    if(l == st && dr == r) {
        if(new_val == 0) {
            arb[k].best = arb[k].suf = arb[k].pref = new_val;
            marked[k] = true;
        } else {
            arb[k].best = arb[k].suf = arb[k].pref = dr-st+1;
        }
    } else {
        push(k);
        int mij = (st + dr) / 2;

        update(k*2, st, mij, l, min(r, mij), new_val);
        update(k*2+1, mij+1, dr, max(l, mij+1), r, new_val);

        combine(k, mij-st+1, dr-mij);
    }
}

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

    build (1, 1, n);
    for(int i = 1; i <= p; ++i) {
        int op; fin >> op;
        if(op == 1) {
            int poz, m; fin >> poz >> m;
            update(1, 1, n, poz, poz+m-1, 0);
        } else if(op == 2) {
            int poz, m; fin >> poz >> m;
            update(1, 1, n, poz, poz+m-1, 1);
        } else {
            fout << arb[1].best << "\n";
        }
    }
    return 0;
}