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

#define int long long

template< typename Monoid, typename OperatorMonoid = Monoid >
struct LazySegmentTree {
    using F = function< Monoid(Monoid, Monoid) >;
    using G = function< Monoid(Monoid, OperatorMonoid, int) >;
    using H = function< OperatorMonoid(OperatorMonoid, OperatorMonoid) >;

    int sz;
    vector< Monoid > data;
    vector< OperatorMonoid > lazy;
    const F f;
    const G g;
    const H h;
    const Monoid M1;
    const OperatorMonoid OM0;


    LazySegmentTree(int n, const F f, const G g, const H h,
            const Monoid &M1, const OperatorMonoid OM0)
        : f(f), g(g), h(h), M1(M1), OM0(OM0) {
            sz = 1;
            while(sz < n) sz <<= 1;
            data.assign(2 * sz, M1);
            lazy.assign(2 * sz, OM0);
        }

    void set(int k, const Monoid &x) {
        data[k + sz] = x;
    }

    void build() {
        for(int k = sz - 1; k > 0; k--) {
            data[k] = f(data[2 * k + 0], data[2 * k + 1]);
        }
    }

    void propagate(int k, int len) {
        if(lazy[k] != OM0) {
            if(k < sz) {
                lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
                lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
            }
            data[k] = g(data[k], lazy[k], len);
            lazy[k] = OM0;
        }
    }

    Monoid update(int a, int b, const OperatorMonoid &x, int k, int l, int r) {
        propagate(k, r - l);
        if(r <= a || b <= l) {
            return data[k];
        } else if(a <= l && r <= b) {
            lazy[k] = h(lazy[k], x);
            propagate(k, r - l);
            return data[k];
        } else {
            return data[k] = f(update(a, b, x, 2 * k + 0, l, (l + r) >> 1),
                    update(a, b, x, 2 * k + 1, (l + r) >> 1, r));
        }
    }

    Monoid update(int a, int b, const OperatorMonoid &x) {
        return update(a, b, x, 1, 0, sz);
    }


    Monoid query(int a, int b, int k, int l, int r) {
        propagate(k, r - l);
        if(r <= a || b <= l) {
            return M1;
        } else if(a <= l && r <= b) {
            return data[k];
        } else {
            return f(query(a, b, 2 * k + 0, l, (l + r) >> 1),
                    query(a, b, 2 * k + 1, (l + r) >> 1, r));
        }
    }

    Monoid query(int a, int b) {
        return query(a, b, 1, 0, sz);
    }

    Monoid operator[](const int &k) {
        return query(k, k + 1);
    }
};

struct Data{
    int cnt;
    int l;
    int r;
};

Data make(int a){
    Data d;
    d.cnt = 0;
    d.l = a;
    d.r = a;
    return d;
}

Data mer(Data a, Data b){
    Data ans;
    if(a.l == -1) return b;
    if(b.l == -1) return a;
    ans.cnt = a.cnt + b.cnt;
    if(a.r != b.l){
        ans.cnt++;
    }
    ans.l = a.l;
    ans.r = b.r;
    return ans;
}

Data merge2(Data a, int b, int x){
    a.l += b;
    a.r += b;
    return a;
}

int merge3(int a, int b){
    return a+b;
}

signed main(){
    int n, q;
    cin >> n >> q;

    LazySegmentTree<Data, int> seg(n, mer, merge2, merge3, make(-1), 0);

    for(int i = 0;i < n;i++){
        int a;
        cin >> a;
        seg.set(i, make(a));
    }

    seg.build();

    for(int p = 0;p < q;p++){
        int a;
        cin >> a;
        if(a == 1){
            int l, r, x;
            cin >> l >> r >> x;
            seg.update(l-1, r, x);
        }else{
            int l, r;
            cin >> l >> r;
            cout << seg.query(l-1, r).cnt+1 << endl;
        }
    }

    return 0;
}