Untitled

/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, OCaml, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
#include <bits/stdc++.h>

using namespace std;

const int N = (int)1e6 + 123;

long long tmax[4 * N], addmax[4 * N];

void pushmax(int v) {
    if (addmax[v]) {
        tmax[2 * v] = max(tmax[2 * v], addmax[v]);
        tmax[2 * v + 1] = max(tmax[2 * v + 1], addmax[v]);
        addmax[2 * v] = max(addmax[2 * v], addmax[v]);
        addmax[2 * v + 1] = max(addmax[2 * v + 1], addmax[v]);
        addmax[v] = 0;
    }
}

void updmax(int v, int tl, int tr, int l, int r, long long val) {
    if (r < tl || tr < l)
        return;
    if (l <= tl && tr <= r) {
        tmax[v] = max(tmax[v], val);
        addmax[v] = val;
        return;
    }
    pushmax(v);
    
    int tm = (tl + tr) / 2;
    updmax(2 * v, tl, tm, l, r, val);
    updmax(2 * v + 1, tm + 1, tr, l, r, val);
    tmax[v] = max(tmax[2 * v], tmax[2 * v + 1]);
}

long long getmax(int v, int tl, int tr, int l, int r) {
    if (r < tl || tr < l)
        return 0;
    if (l <= tl && tr <= r) 
        return tmax[v];
    pushmax(v);
        
    int tm = (tl + tr) / 2;
    long long L = getmax(2 * v, tl, tm, l, r);
    long long R = getmax(2 * v + 1, tm + 1, tr, l, r);
    return max(L, R);
}

int t[4 * N], add[4 * N];

void push(int v) {
    if (add[v]) {
        t[2 * v] += add[v];
        t[2 * v + 1] += add[v];
        add[2 * v] += add[v];
        add[2 * v + 1] += add[v];
        add[v] = 0;
    }
}

void upd(int v, int tl, int tr, int l, int r, int val) {
    if (tr < l || r < tl)
        return;
    if (l <= tl && tr <= r) {
        t[v] += val;
        add[v] += val;
        return;
    }
    push(v);
    
    int tm = (tl + tr) / 2;
    upd(2 * v, tl, tm, l, r, val);
    upd(2 * v + 1, tm + 1, tr, l, r, val);
    t[v] = max(t[2 * v], t[2 * v + 1]);
}

int getpos(int v, int tl, int tr, int pos) {
    if (tl == tr)
        return t[v];
    push(v);
    
    int tm = (tl + tr) / 2;
    if (pos <= tm)
        return getpos(2 * v, tl, tm, pos);
    return getpos(2 * v + 1, tm + 1, tr, pos);
}

struct item{
    int type;
    long long l, r, pos;
    long long val;
}query[N];

int W, q, n;
set<long long> zs;
map<long long, int> zm;

void solve() {
    cin >> W >> q;
    for (int i = 1; i <= q; i++) {
        cin >> query[i].type;
        if (query[i].type == 1) {
            int l, r;
            long long h;
            cin >> l >> r >> h;
            
            long long H = getmax(1, 1, W, l, r);
            updmax(1, 1, W, l, r, H + h);
            
            query[i].val = r - l + 1;
            query[i].l = H + 1;
            query[i].r = H + h;
        } else {
            cin >> query[i].pos;
        }
    }
    
    for (int i = 1; i <= q; i++) {
        if (query[i].type == 1) {
            zs.insert(query[i].l);
            zs.insert(query[i].r);
        } else {
            zs.insert(query[i].pos);
        }
    }
    
    n = 0;
    for (long long x : zs) {
        n++;
        zm[x] = n;
    }
    
    for (int i = 1; i <= q; i++) {
        if (query[i].type == 1) {
            int l = zm[query[i].l];
            int r = zm[query[i].r];
            long long val = query[i].val;
            upd(1, 1, n, l, r, val);
        } else {
            int pos = zm[query[i].pos];
            cout << getpos(1, 1, n, pos) << '\n';
        }
    }
}

int main()
{   
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    solve();
    return 0;
}