#include <iostream>
#include <vector>
#include <fstream>
#include <cmath>
#include <algorithm>
using namespace std;
ifstream in("hotel.in");
ofstream out("hotel.out");

struct seq{
    int dp, st, m;
    int carry = -1; // 0 daca umplem camerele 1 daca le eliberam, -1 daca nimic
};

void init(int node, int l, int r, vector<seq> &tree)
{
    if (l == r)
    {
        tree[node].dp = 1;
        tree[node].st = 1;
        tree[node].m = 1;
    }
    else
    {
        int mij = (l + r) / 2;

        init(2*node, l, mij, tree);
        init(2*node + 1, mij + 1, r, tree);

        if (tree[2*node].st == mij - l + 1)
            tree[node].st = tree[2*node].st + tree[2*node + 1].st;
        else
            tree[node].st = tree[2*node].st;

        if (tree[2*node + 1].dp == r - mij)
            tree[node].dp = tree[2*node + 1].dp + tree[2*node].dp;
        else
            tree[node].dp = tree[2*node + 1].dp;

        tree[node].m = max(tree[2*node].m, max(tree[2*node + 1].m, tree[2*node].dp + tree[2*node + 1].st));
    }
}

void room_oper(int type, int node, int l, int r, int ql, int qr, vector<seq> &tree)
{
    if (ql <= l && r <= qr)
    {
        switch(type)
        {
            case 1:{
                tree[node].st = 0;
                tree[node].dp = 0;
                tree[node].m = 0;
                tree[node].carry = 0;
            break;}
            case 2:{
                tree[node].st = r - l + 1;
                tree[node].dp = r - l + 1;
                tree[node].m = r - l + 1;
                tree[node].carry = 1;
            break;}
        }
    }
    else
    {
        int mij = (l + r) / 2;

       switch(tree[node].carry)
        {
            case 0:{
                tree[2*node].st = 0; tree[2*node].dp = 0; tree[2*node].m = 0;
                tree[2*node + 1].st = 0; tree[2*node].dp = 0; tree[2*node + 1].m = 0;
                tree[2*node].carry = 0; tree[2*node + 1].carry = 0;
                tree[node].carry = -1;
            break;}

            case 1:{ int l1 = mij - l + 1, l2 = r - mij;
                tree[2*node].st = l1; tree[2*node].dp = l1; tree[2*node].m = l1;
                tree[2*node + 1].st = l2; tree[2*node].dp = l2; tree[2*node + 1].m = l2;
                tree[2*node].carry = 1; tree[2*node + 1].carry = 1;
                tree[node].carry = -1;
            break;}
        }
        
        if (ql <= mij)
            room_oper(type, 2*node, l, mij, ql, qr, tree);
        if (mij + 1 <= qr)
            room_oper(type, 2*node + 1, mij + 1, r, ql, qr, tree);


        if (tree[2*node].st == mij - l + 1)
            tree[node].st = tree[2*node].st + tree[2*node + 1].st;
        else
            tree[node].st = tree[2*node].st;

        if (tree[2*node + 1].dp == r - mij)
            tree[node].dp = tree[2*node + 1].dp + tree[2*node].dp;
        else
            tree[node].dp = tree[2*node + 1].dp;

        tree[node].m = max(tree[2*node].m, max(tree[2*node + 1].m, tree[2*node].dp + tree[2*node + 1].st));
    }
}

int main()
{
    int n, Q;
    in>> n >> Q;
    vector<seq> tree(4 * n);
    init(1, 0, n - 1, tree);

    for (int question = 0; question < Q; question++)
    {
        int type;
        in>> type;

        if (type == 3)
        {
            out<< tree[1].m << "\n";
            continue;
        }
        int a, b;
        in>> a >> b;

        room_oper(type, 1, 0, n - 1, a - 1, a + b - 2, tree);
    }
    return 0;
}