#include <iostream>

#include <algorithm>
#include <fstream>

using namespace std;

struct AINT
{
    int left, right, best, sum;
    bool flag;
    AINT()
    {
        this->left = this->right = this->best = this->sum = 0;
        this->flag = false;
    }
    AINT(const int &left, const int &right, const int &best, const bool &flag)
   {
       this->left = left;
       this->right = right;
       this->best = best;
       this->flag = flag;
   }
};

const int NMAX = 100010;
int n, p, op;
AINT aint[4 * NMAX];

inline int LeftSon(const int &x)
{
    return 2 * x;
}

inline int RightSon(const int &x)
{
    return 2 * x + 1;
}

void Build(int node, int left, int right)
{
    if (left == right)
    {
        aint[node] = AINT(1, 1, 1, false);
        aint[node].sum = 1;
        return;
    }
    int mid = (left + right) / 2;
    Build(LeftSon(node), left, mid);
    Build(RightSon(node), mid + 1, right);
    aint[node].left = aint[LeftSon(node)].left + aint[RightSon(node)].left;
    aint[node].right = aint[LeftSon(node)].right + aint[RightSon(node)].right;
    aint[node].best = aint[LeftSon(node)].best + aint[RightSon(node)].best;
    aint[node].sum = aint[LeftSon(node)].sum + aint[RightSon(node)].sum;
    aint[node].flag = false;
}

void Update(int node, int left, int right, const int &LeftQuery, const int &RightQuery)
{
    if (LeftQuery <= left && right <= RightQuery)
    {
        if (op == 1)
        {
            ///vin oameni
            aint[node] = AINT(0, 0, 0, true);
            if (left == right)
                aint[node].sum = 1;
            else
                aint[node].sum = aint[LeftSon(node)].sum + aint[RightSon(node)].sum;
        }
        else
        {
            ///pleaca oameni
            aint[node].flag = false;

            aint[node].left = aint[RightSon(node)].left;
            if (aint[node].left != 0 && aint[RightSon(node)].left == aint[RightSon(node)].sum)
                aint[node].left = aint[LeftSon(node)].left + aint[RightSon(node)].sum;

            aint[node].right = aint[LeftSon(node)].right;
            if (aint[node].right != 0 && aint[LeftSon(node)].right == aint[LeftSon(node)].sum)
                aint[node].right = aint[LeftSon(node)].sum + aint[RightSon(node)].right;

            aint[node].best = max(max(aint[LeftSon(node)].best, aint[RightSon(node)].best), aint[LeftSon(node)].left + aint[RightSon(node)].right);
        }

        return;
    }
    int mid = (left + right) / 2;
    if (LeftQuery <= mid)
    {
        if (aint[node].flag == true)
        {
            aint[node].flag = false;
            ///frunzele
            aint[LeftSon(node)].flag = true;
            aint[RightSon(node)].flag = true;
        }
        Update(LeftSon(node), left, mid, LeftQuery, RightQuery);
    }
    if (RightQuery >= mid + 1)
    {
        if (aint[node].flag == true)
        {
            aint[node].flag = false;
            ///frunzele
            aint[LeftSon(node)].flag = true;
            aint[RightSon(node)].flag = true;
        }
        Update(RightSon(node), mid + 1, right, LeftQuery, RightQuery);
    }
    if (aint[LeftSon(node)].flag == true && aint[RightSon(node)].flag == true)
        aint[node] = AINT(0, 0, 0, false);
    else if (aint[LeftSon(node)].flag == false && aint[RightSon(node)].flag == true)
    {
        aint[node].left = 0;
        aint[node].right = aint[LeftSon(node)].right;
        aint[node].best = aint[LeftSon(node)].best;
    }
    else if (aint[LeftSon(node)].flag == true && aint[RightSon(node)].flag == false)
    {
        aint[node].right = 0;
        aint[node].left = aint[RightSon(node)].left;
        aint[node].best = aint[RightSon(node)].best;
    }
    else
    {
        aint[node].left = aint[RightSon(node)].left;
        if (aint[node].left != 0 && aint[RightSon(node)].left == aint[RightSon(node)].sum)
            aint[node].left = aint[LeftSon(node)].left + aint[RightSon(node)].sum;

        aint[node].right = aint[LeftSon(node)].right;
        if (aint[node].right != 0 && aint[LeftSon(node)].right == aint[LeftSon(node)].sum)
            aint[node].right = aint[LeftSon(node)].sum + aint[RightSon(node)].right;

        aint[node].best = max(max(aint[LeftSon(node)].best, aint[RightSon(node)].best), aint[LeftSon(node)].left + aint[RightSon(node)].right);
    }

}

inline int Query()
{
    return aint[1].best;
}

int main()
{
    ifstream fin("hotel.in");
    ofstream fout("hotel.out");
    fin >> n >> p;
    int st, cnt;
    Build(1, 1, n);
    for (int i = 1;i <= p;++i)
    {
        fin >> op;
        if (op == 1)
        {
            fin >> st >> cnt;
            Update(1, 1, n, st, st + cnt - 1);
        }
        else if (op == 2)
        {
            fin >> st >> cnt;
            Update(1, 1, n, st, st + cnt - 1);
        }
        else
            fout << Query() << "\n";
    }
    fin.close();
    fout.close();
    return 0;
}