#include <stdio.h>
#include <stdlib.h>


typedef struct {
    int start;
    int end;
    int max_length;
} IntervalNode;


typedef struct {
    IntervalNode *nodes;
    int size;
} IntervalTree;


IntervalNode createIntervalNode(int start, int end) {
    IntervalNode node;
    node.start = start;
    node.end = end;
    node.max_length = end - start + 1;
    return node;
}


IntervalTree *initializeIntervalTree(int size) {
    IntervalTree *tree = (IntervalTree *)malloc(sizeof(IntervalTree));
    tree->nodes = (IntervalNode *)malloc((2 * size) * sizeof(IntervalNode));
    tree->size = size;

    for (int i = 0; i < size; i++) {
        tree->nodes[size + i] = createIntervalNode(i + 1, i + 1);
    }

    for (int i = size - 1; i > 0; i--) {
        tree->nodes[i] = createIntervalNode(tree->nodes[2 * i].start, tree->nodes[2 * i + 1].end);
        tree->nodes[i].max_length = tree->nodes[2 * i].max_length;
    }
    return tree;
}


void updateIntervalNode(IntervalTree *tree, int index) {
    while (index > 1) {
        index /= 2;
        tree->nodes[index].max_length = tree->nodes[2 * index].max_length;
        if (tree->nodes[2 * index].end + 1 == tree->nodes[2 * index + 1].start) {
            tree->nodes[index].max_length = tree->nodes[2 * index].max_length + tree->nodes[2 * index + 1].max_length;
        }
    }
}


void occupyInterval(IntervalTree *tree, int start, int end) {
    start--;
    end--;
    int index = tree->size + start;
    tree->nodes[index].max_length = 0;
    updateIntervalNode(tree, index);
}


void releaseInterval(IntervalTree *tree, int start, int end) {
    start--;
    end--;
    int index = tree->size + start;
    tree->nodes[index].max_length = end - start + 1;
    updateIntervalNode(tree, index);
}


int findMaxLength(IntervalTree *tree) {
    return tree->nodes[1].max_length;
}

int main() {
    FILE *fin, *fout;
    fin = fopen("hotel.in", "r");
    fout = fopen("hotel.out", "w");

    int N, P;
    fscanf(fin, "%d %d", &N, &P);


    IntervalTree *tree = initializeIntervalTree(N);


    for (int i = 0; i < P; i++) {
        int type, start, num_members;
        fscanf(fin, "%d", &type);
                if (type == 1) {
            fscanf(fin, "%d %d", &start, &num_members);
            occupyInterval(tree, start, start + num_members - 1);
        } else if (type == 2) {
            fscanf(fin, "%d %d", &start, &num_members);
            releaseInterval(tree, start, start + num_members - 1);
        } else if (type == 3) {
            fprintf(fout, "%d\n", findMaxLength(tree));
        }
    }

    fclose(fin);
    fclose(fout);


    free(tree->nodes);
    free(tree);

    return 0;
}