#include <bits/stdc++.h>
#define int long long
using namespace std;
const int INF = 1e18;

template< typename T, typename E >
struct SegmentTree{
    using F = function< T(T, T) >;
    using G = function< T(T, E) >;
    int sz;
    vector<T> dat;
    F f;
    G g;
    T t1;
    SegmentTree(int n, F f, G g, T t1) : f(f), g(g), t1(t1) {
        sz = 1;
        while(sz < n) sz *= 2;
        dat.clear();
        dat.resize(2 * sz - 1, t1);
    }
    void set(int k, T x) { dat[k + sz - 1] = x; }
    void build() {
        for(int k = sz - 2; k >= 0; k--) {
            dat[k] = f(dat[2 * k + 1], dat[2 * k + 2]);
        }
    }
    void update(int k, E x) {
        k += sz - 1;
        dat[k] = g(dat[k], x);
        while(k > 0) {
            k = (k - 1) / 2;
            dat[k] = f(dat[2 * k + 1], dat[2 * k + 2]);
        }
    }
    T query(int a, int b, int k, int l, int r) {
        if(r <= a || b <= l) return t1;
        if(a <= l && r <= b) return dat[k];
        T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
        T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
        return f(vl, vr);
    }
    T query(int a, int b){ return query(a, b, 0, 0, sz); }
    T operator[](int k) { return dat[k + sz - 1]; }
};

template< typename T, typename E = T >
struct LazySegmentTree {
    using F = function< T(T, T) >;
    using G = function< T(T, E) >;
    using H = function< E(E, E) >;
    using P = function< E(E, int) >;
    int sz;
    vector<T> dat;
    vector<E> lazy;
    F f;
    G g;
    H h;
    P p;
    T d1;
    E d0;

    LazySegmentTree(int n, F f, G g, H h, P p, T d1, E d0) : f(f), g(g), h(h), p(p), d1(d1), d0(d0) {
        sz = 1;
        while(sz < n) sz *= 2;
        dat.clear();
        dat.resize(2 * sz - 1, d1);
        lazy.clear();
        lazy.resize(2 * sz - 1, d0);
    }
    void set(int k, T x) { dat[k + sz - 1] = x; }
    void build() {
        for(int k = sz - 2; k >= 0; k--) {
            dat[k] = f(dat[2 * k + 1], dat[2 * k + 2]);
        }
    }
    inline void eval(int k, int len){
        if(lazy[k] == d0) return;
        if(k * 2 + 1 < sz * 2 - 1) {
            lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
            lazy[2 * k + 2] = h(lazy[2 * k + 2], lazy[k]);
        }
        dat[k] = g(dat[k], p(lazy[k], len));
        lazy[k] = d0;
    }
    T update(int a, int b, E x, int k, int l, int r) {
        eval(k, r - l);
        if(r <= a || b <= l) return dat[k];
        if(a <= l && r <= b) {
            lazy[k] = h(lazy[k], x);
            eval(k, r - l);
            return dat[k];
        }
        return dat[k] = f(update(a, b, x, 2 * k + 1, l, (l + r) / 2), update(a, b, x, 2 * k + 2, (l + r) / 2, r));
    }
    T update(int a, int b, E x) { return update(a, b, x, 0, 0, sz); }
    T query(int a, int b, int k, int l, int r) {
        eval(k, r - l);
        if(r <= a || b <= l) return d1;
        if(a <= l && r <= b) return dat[k];
        T vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
        T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
        return f(vl, vr);
    }
    T query(int a, int b) { return query(a, b, 0, 0, sz); }
    T operator[](int k) { return query(k, k + 1); }
};

signed main(){
    int n, q;
    cin >> n >> q;
    auto f = [](int a, int b) { return min(a, b); };
    auto g = [](int a, int b) { return a + b; };
    auto h = [](int a, int b) { return a + b; };
    auto p = [](int a, int b) { return a; };
    LazySegmentTree<int> seg(n, f, g, h, p, INF, 0);
    SegmentTree<int, int> seg2(n,
        [](int a, int b){ return a + b; },
        [](int a, int b){ return b; },
        0);
    vector<int> a(n);
    for(int i = 0; i < n; i++){
        cin >> a[i];
        seg.set(i, a[i]);
    }
    for(int i = 0; i < n - 1; i++){
        seg2.set(i, (a[i] != a[i + 1]));
    }
    seg.build();
    seg2.build();
    for(int i = 0; i < q; i++){
        int c, l, r;
        cin >> c >> l >> r;
        l--; r--;
        if(c == 1){
            int x;
            cin >> x;
            seg.update(l, r + 1, x);
            if(l > 0) seg2.update(l - 1, (seg[l - 1] != seg[l]));
            if(r < n - 1) seg2.update(r, (seg[r] != seg[r + 1]));
        }else{
            cout << seg2.query(l, r) + 1 << endl;
        }
    }
}