#include <fstream>
#include <algorithm>
#include <iostream>

using namespace std;

ifstream cin("hotel.in");
ofstream cout("hotel.out");

const int N = 100000;

struct tree_node
{
    int max;
    int left_max;
    int right_max;
    int lazy;
};

tree_node segment_tree[N * 4 + 1];

void update_lazy()
{

}

void update_node(int node, int left, int right)
{
    int mid = (left + right) / 2, left_son = 2 * node, right_son = 2 * node + 1;

    segment_tree[node].left_max =
        (segment_tree[left_son].left_max == middle - left + 1) ?
        middle - left + 1 + segment_tree[right_son].left_max:
        segment_tree[left_son].left_max;

    segment_tree[node].right_max =
        (segment_tree[right_son].right_max == left - middle) ?
        left - middle + segment_tree[left_son].right_max:
        segment_tree[right_son].right_max;

    segment_tree[node].max =
        std::max(segment_tree[left_son].right_max + segment_tree[right_son].left_max,
                 std::max(segment_tree[left_son].max,
                          segment_tree[right_son].max));
}

void update()
{

}

int main(int argc, const char *argv[])
{
    std::ifstream in("hotel.in");
    std::ofstream out("hotel.out");

    int n, q;
    in >> n >> q;

    segment_tree[1].lazy = 2;
    while (q--)
    {
        int type;
        in >> type;

        if (type <= 2)
        {
            int left, count;
            in >> left >> count;

            int right = left + count - 1;
            update(1, 1, n, left, right, type);
        }
        else
        {
            update_lazy(1, 1, n);
            out << segment_tree[1].max << "\n";
        }
    }

    return 0;
}