#include <bits/stdc++.h>
using namespace std;

/// MORBESC
///                         __
///                   _.--""  |
///    .----.     _.-'   |/\| |.--.
///    |    |__.-'   _________|  |_)  _______________
///    |  .-""-.""""" ___,    `----'"))   __   .-""-.""""--._
///    '-' ,--. `    |Luka77| .---.       |:.| ' ,--. `      _`.
///     ( (    ) ) __|  7  |__\\|// _..-- \/ ( (    ) )--._".-.
///      . `--' ;\__________________..--------. `--' ;--------'
///       `-..-'                               `-..-'

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

/// STRUCTURES
struct tree_node
{
    int st, dr;
    short lazy;
};

/// GLOBAL VARIABLES
const int NMAX = 1e5 + 5;
int n, q;
tree_node tree[5*NMAX];

inline void update_node(int node)
{
    if(tree[node*2].dr + 1 == tree[node*2+1].st)
    {
        tree[node].st = tree[node*2].st;
        tree[node].dr = tree[node*2+1].dr;
    }
    else if(!tree[node*2].dr && tree[node*2+1].st)
    {
        tree[node].st = tree[node*2+1].st;
        tree[node].dr = tree[node*2+1].dr;
    }
    else if(tree[node*2].dr && !tree[node*2+1].st)
    {
        tree[node].st = tree[node*2].st;
        tree[node].dr = tree[node*2].dr;
    }
    else if(tree[node*2].dr && tree[node*2+1].st)
    {
        if(tree[node*2].dr - tree[node*2].st + 1 > tree[node*2+1].dr - tree[node*2+1].st + 1)
        {
            tree[node].st = tree[node*2].st;
            tree[node].dr = tree[node*2].dr;
        }
        else
        {
            tree[node].st = tree[node*2+1].st;
            tree[node].dr = tree[node*2+1].dr;
        }
    }
}

inline void build(int node, int left, int right)
{
    if(left == right)
    {
        tree[node].st = left;
        tree[node].dr = right;
    }
    else
    {
        int mid = (left + right) / 2;

        build(node*2, left, mid);
        build(node*2+1, mid + 1, right);

        update_node(node);
    }
}

inline void lazy_update(int node, int left, int right)
{
    if(tree[node].lazy == 2)
    {
        tree[node].st = left;
        tree[node].dr = right;

        if(left != right)
        {
            tree[node*2].lazy = 2;
            tree[node*2+1].lazy = 2;
        }
    }
    if(tree[node].lazy == 1)
    {

        tree[node].st = 0;
        tree[node].dr = 0;
        if(left != right)
        {
            tree[node*2].lazy = 1;
            tree[node*2+1].lazy = 1;
        }
    }
    tree[node].lazy = 0;
}

inline void update(int node, int left, int right, int arbst, int arbdr, bool adaos)
{
    lazy_update(node, 1, n);
    if(left >= arbst && right <= arbdr)
    {
        if(adaos)
            tree[node].lazy = 2;
        else
            tree[node].lazy = 1;
        lazy_update(node, left , right);
    }
    else
    {
        int mid = (left + right) / 2;
        lazy_update(node, left, right);
        if(arbst <= mid)
            update(node*2, left, mid, arbst, arbdr, adaos);
        if(mid + 1 <= arbdr)
            update(node*2+1, mid + 1, right, arbst, arbdr, adaos);
        lazy_update(node*2, left, mid);
        lazy_update(node*2+1, mid + 1, right);
        update_node(node);
    }
}

/// READING THE OUTPUT
int main()
{
    ios::sync_with_stdio(false);
    fin.tie(NULL);
    fout.tie(NULL);
    fin >> n >> q;
    build(1, 1, n);
    while(q--)
    {
        int type;
        fin >> type;
        if(type == 1)
        {
            int a, b;
            fin >> a >> b;
            update(1, 1, n, a, a + b - 1, false);
        }
        if(type == 2)
        {
            int a, b;
            fin >> a >> b;
            update(1, 1, n, a, a + b - 1, true);
        }
        if(type == 3)
        {
            fout << tree[1].dr - tree[1].st + 1 << '\n';
        }
    }
}