#include <bits/stdc++.h>

using i64 = long long;

constexpr int inf = 1E9;

struct Tag {
    int sum = 0;
    int min = 0;
    int save = inf;
    int load = -inf;
};

Tag operator*(const Tag &a, const Tag &b) {
    Tag c;
    if (a.sum + b.load >= a.save) {
        c.sum = a.save + b.sum - b.load;
        c.min = std::min(a.min, a.save + b.min - b.load);
        c.save = a.save + b.save - b.load;
        c.load = a.min;
    } else {
        c.sum = a.sum + b.sum;
        c.min = std::min(a.min, a.sum + b.min);
        if (a.sum + b.min < a.save) {
            c.save = a.sum + b.save;
        } else {
            c.save = a.save;
        }
        c.load = std::max(a.load, std::min(a.min, a.sum + b.load));
    }
    return c;
}

constexpr int N = 1 << 20;

Tag op[5];
std::vector<Tag> tag(N);

void apply(int p, const Tag &m) {
    tag[p] = tag[p] * m;
}

void push(int p) {
    apply(2 * p, tag[p]);
    apply(2 * p + 1, tag[p]);
    tag[p] = {};
}

void modify(int p, int l, int r, int x, int y, int v) {
    if (l >= y || r <= x) {
        return;
    }
    if (l >= x && r <= y) {
        apply(p, op[v]);
        return;
    }
    int m = (l + r) / 2;
    push(p);
    modify(2 * p, l, m, x, y, v);
    modify(2 * p + 1, m, r, x, y, v);
}

int query(int p, int l, int r, int x) {
    if (r - l == 1) {
        return 500000 + tag[p].sum;
    }
    int m = (l + r) / 2;
    push(p);
    if (x < m) {
        return query(2 * p, l, m, x);
    } else {
        return query(2 * p + 1, m, r, x);
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, q;
    std::cin >> n >> q;
    
    op[1] = {1, 0, inf, -inf};
    op[2] = {-1, -1, inf, -inf};
    op[3] = {0, 0, 0, -inf};
    op[4] = {0, 0, inf, 0};
    
    for (int _ = 0; _ < q; _++) {
        int o, l, r;
        std::cin >> o >> l >> r;
        l--;
        
        if (o <= 4) {
            modify(1, 0, n, l, r, o);
        } else {
            std::cout << query(1, 0, n, l) << "\n";
        }
    }
    
    return 0;
}