#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;

mt19937 rnd((unsigned long long)new char ^time(0));

const int mod = 1e9 + 7;
const int base = rnd() % 1000000 + 1000000 + 13579;

ll pwb[MAXN], sumpwb[MAXN];
struct Hash {
    int h, len;
    Hash(void) {}
    explicit Hash(int x): h(x), len(1) {}
    Hash(int _h, int _len): h(_h), len(_len) {}
};
Hash operator + (const Hash &p, const Hash &q) {
    return Hash(((ll)p.h * pwb[q.len] + q.h) % mod, p.len + q.len);
}
Hash shift(const Hash &p, int k) {
    return Hash((p.h + (ll)(k + mod) * sumpwb[p.len - 1]) % mod, p.len);
}
inline bool operator == (const Hash &p, const Hash &q) {
    return p.h == q.h && p.len == q.len;
}

struct Segment_Tree_Hash {
    Hash h[MAXN << 2];
    int tag[MAXN << 2];
#define ls(u) ((u)<<1)
#define rs(u) ((u)<<1|1)
#define lson(u) ls(u),l,mid
#define rson(u) rs(u),mid+1,r
    void push_up(int u) {
        h[u] = h[ls(u)] + h[rs(u)];
    }
    void upd(int u, int k) {
        h[u] = shift(h[u], k);
        tag[u] += k;
    }
    void push_down(int u) {
        if (tag[u]) {
            upd(ls(u), tag[u]);
            upd(rs(u), tag[u]);
            tag[u] = 0;
        }
    }
    void build(int u, int l, int r, int a[]) {
        if (l == r) {
            h[u] = Hash(a[l]);
            return;
        }

        int mid = (l + r) >> 1;
        build(lson(u), a);
        build(rson(u), a);
        push_up(u);
    }
    Hash query(int u, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr)
            return h[u];

        push_down(u);
        int mid = (l + r) >> 1;

        if (ql <= mid && mid < qr)
            return query(lson(u), ql, qr) + query(rson(u), ql, qr);
        else
            return ql <= mid ? query(lson(u), ql, qr) : query(rson(u), ql, qr);
    }
    void add(int u, int l, int r, int ql, int qr, int k) {
        if (ql <= l && r <= qr) {
            upd(u, k);
            return;
        }

        push_down(u);
        int mid = (l + r) >> 1;

        if (ql <= mid)
            add(lson(u), ql, qr, k);

        if (mid < qr)
            add(rson(u), ql, qr, k);

        push_up(u);
    }

    int n;
    int orih[MAXN];
    bool hasupd;
    void build(int _n, int a[]) {
        n = _n;
        build(1, 1, n, a);
        hasupd = 0;

        for (int i = 1; i <= n; ++i)
            orih[i] = ((ll)orih[i - 1] * base + a[i]) % mod;
    }
    Hash query(int ql, int qr) {
        if (!hasupd)
            return Hash((orih[qr] - (ll)orih[ql - 1] * pwb[qr - ql + 1] % mod + mod) % mod);
        else
            return query(1, 1, n, ql, qr);
    }
    void add(int ql, int qr, int k) {
        hasupd = 1;
        add(1, 1, n, ql, qr, k);
    }

    int cmp(int l1, int r1, int l2, int r2) {
        if (l1 > r1 && l2 > r2)
            return 0;

        if (l1 > r1)
            return -2;

        if (l2 > r2)
            return 2;

        int lim = min(r1 - l1 + 1, r2 - l2 + 1);
        int vl = 0, vr = lim;

        while (vl < vr) {
            int mid = (vl + vr + 1) >> 1;

            if (query(l1, l1 + mid - 1) == query(l2, l2 + mid - 1))
                vl = mid;
            else
                vr = mid - 1;
        }

        if (vl == lim)
            return r1 - l1 == r2 - l2 ? 0 : r1 - l1 < r2 - l2 ? -2 : 2;
        else
            return query(l1 + vl, l1 + vl).h < query(l2 + vl, l2 + vl).h ? -1 : 1;
    }
    int cmp(pii p, pii q) {
        return cmp(p.first, p.second, q.first, q.second);
    }
} hshtree;

struct Data {
    int x, y, k, to;
    Data(void) {}
    Data(int _x, int _y, int _k, int _to): x(_x), y(_y), k(x == y ? 0 : _k), to(_to) {}
    Data(int l, int r): x(l), y(l), k(0), to(r) {}
    Data ext(int nxt) const {
        if (x == y)
            return Data(x, y, k, nxt);

        int t = hshtree.cmp(x, nxt, x + k, nxt);

        if (t == 2)
            return Data(x, y, k, nxt);

        if (t < 0)
            return Data(x, nxt);
        else
            return Data(y, nxt);
    }
    pii segX(void) const {
        return {x, to};
    }
    pii segY(void) const {
        return {y, to};
    }
};

struct Lis {
    vector<Data> vec;
    Lis(void) {}
    Lis(const vector<Data> &_vec): vec(_vec) {}
    Lis(const Data &dat): vec(1, dat) {}
};

ostream &operator << (ostream &os, const Data &p) {
    return os << p.x << " " << p.y << " " << p.k << " " << p.to;
}
ostream &operator << (ostream &os, const Lis &p) {
    for (auto t : p.vec)
        os << t << endl;

    return os;
}

Lis operator + (const Lis &p, const Lis &q) {
    int nxt = q.vec[0].to;
    vector<Data> res = q.vec;

    for (const Data &t : p.vec) {
        Data cur = t.ext(nxt);

        while (res.size() && hshtree.cmp(cur.segY(), res.back().segY()) <= 0)
            res.pop_back();

        if (res.size()) {
            if (hshtree.cmp(cur.segY(), res.back().segX()) == 1)
                continue;

            if (res.back().k != 0) {
                Data oth = res.back();
                res.pop_back();
                int l = 0, r = (oth.y - oth.x) / oth.k;

                while (l < r) {
                    int mid = (l + r) >> 1;

                    if (hshtree.cmp(cur.segY(), {oth.x + oth.k * l, oth.to}) == 2)
                        r = mid;
                    else
                        l = mid + 1;
                }

                oth.x += l * oth.k;

                if (oth.x == oth.y)
                    oth.k = 0;

                res.push_back(oth);
            }
        }

        res.push_back(cur);
    }

    vector<Data> res2;

    for (Data y : res) {
        if (!res2.size()) {
            res2.push_back(y);
            continue;
        }

        Data x = res2.back();
        bool ok = 1;

        if (x.k && y.k && x.k != y.k)
            ok = 0;

        if (x.k && x.k != x.x - y.y)
            ok = 0;

        if (y.k && y.k != x.x - y.y)
            ok = 0;

        if (ok) {
            res2.pop_back();
            res2.push_back(Data(y.x, x.y, x.x - y.y, y.to));
        } else {
            res2.push_back(y);
        }
    }

    return res2;
}

struct Segment_Tree_list {
    Lis tree[MAXN << 2];
    inline void push_up(int u) {
        tree[u] = tree[ls(u)] + tree[rs(u)];
    }
    void build(int u, int l, int r) {
        if (l == r) {
            tree[u] = Data(l, l);
            return;
        }

        int mid = (l + r) >> 1;
        build(lson(u));
        build(rson(u));
        push_up(u);
    }
    void update(int u, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr)
            return;

        int mid = (l + r) >> 1;

        if (ql <= mid)
            update(lson(u), ql, qr);

        if (mid < qr)
            update(rson(u), ql, qr);

        push_up(u);
    }
    Lis query(int u, int l, int r, int ql, int qr) {
        if (ql <= l && r <= qr) {
            //          cout << "tree [" << l << ", " << r << "]:\n" << tree[u] << endl;
            return tree[u];
        }

        int mid = (l + r) >> 1;

        if (ql <= mid && mid < qr) {
            auto res = query(lson(u), ql, qr) + query(rson(u), ql, qr);
            //          cout << "cur [" << max(l,ql) << ", " << min(r,qr) << "]:\n" << res << endl;
            return res;
        } else
            return ql <= mid ? query(lson(u), ql, qr) : query(rson(u), ql, qr);
    }
} tree;

int n, Q;
int a[MAXN];

namespace Subtask1 {
const int MAXN = 3e2 + 5;
int lcp[MAXN][MAXN];
void buildlcp(void) {
    for (int i = n; i >= 1; --i)
        for (int j = n; j >= 1; --j)
            lcp[i][j] = a[i] == a[j] ? lcp[i + 1][j + 1] + 1 : 0;
}
void solve(void) {
    buildlcp();
    bool tag = 1;

    while (Q--) {
        int type, l, r;
        scanf("%d%d%d", &type, &l, &r);

        if (type == 1) {
            int k;
            scanf("%d", &k);

            for (int i = l; i <= r; ++i)
                a[i] += k;

            tag = 0;
        } else {
            if (!tag)
                buildlcp(), tag = 1;

            int mn = l;

            for (int i = l + 1; i <= r; ++i) {
                int len = min(r - i + 1, lcp[mn][i]);

                if (len == r - i + 1)
                    mn = i;
                else if (a[mn + len] > a[i + len])
                    mn = i;
            }

            printf("%d\n", mn);
        }
    }
}
}

namespace Subtask2 {
void solve(void) {
    pwb[0] = 1;

    for (int i = 1; i < MAXN; ++i)
        pwb[i] = (ll)pwb[i - 1] * base % mod;

    sumpwb[0] = pwb[0];

    for (int i = 1; i < MAXN; ++i)
        sumpwb[i] = (sumpwb[i - 1] + pwb[i]) % mod;

    const int CCC = 1e8 + 3e7 + 1;

    for (int i = 1; i <= n; ++i)
        a[i] += CCC;

    hshtree.build(n, a);
    tree.build(1, 1, n);

    while (Q--) {
        int type, l, r;
        scanf("%d%d%d", &type, &l, &r);

        if (type == 1) {
            int k;
            scanf("%d", &k);
            hshtree.add(l, r, k);
            tree.update(1, 1, n, l, r);
        } else {
            auto res = tree.query(1, 1, n, l, r);
            printf("%d\n", res.vec[0].y);
        }
    }
}
}

int main(void) {
    scanf("%d%d", &n, &Q);

    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);

    if (n <= 300)
        Subtask1::solve();
    else
        Subtask2::solve();

    return 0;
}