#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
#define sz(s) (int)(s).size()
#define all(s) s.begin(),s.end()

void Speed() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
}

struct Node {
    ll val = 1e17, lazy = 0;
} neutral;
struct segtree {
    segtree *left = nullptr, *right = nullptr;
    Node node = {};
    int start, end;
    segtree(int l = 0, int r = 0) : start(l), end(r) {}

    void extend() {
        if (left == nullptr) {
            int mid = start + end >> 1;
            left = new segtree(start, mid);
            right = new segtree(mid + 1, end);
        }
    }
    Node pushup(Node a, Node b) {
        Node ret;
        ret.val = min(a.val, b.val);
        return ret;
    }
    void pushdown() {
        node.val += node.lazy;
        if (start != end) {
            extend();
            left->node.lazy += node.lazy;
            right->node.lazy += node.lazy;
        }
        node.lazy = 0;
    }

    void update(int l, int r, ll val, bool set_upd = 0) {
        pushdown();
        if (start > r || end < l)
            return;
        if (start >= l && end <= r) {
            if(set_upd){
                assert(l == r);
                node.val = val;
                return;
            }
            node.lazy = val;
            pushdown();
            return;
        }
        extend();
        left->update(l, r, val, set_upd);
        right->update(l, r, val, set_upd);
        node = pushup(left->node, right->node);
    }
    Node query(int l, int r) {
        pushdown();
        if (r < start || end < l)
            return neutral;
        if (l <= start && end <= r)
            return node;
        extend();
        Node ret = pushup(left->query(l , r), right->query(l , r));
        return ret;
    }
    ~segtree() {
        if (left == nullptr)return;
        delete left;
        delete right;
    }
}*A, *B;


struct Node1{
    ll need = 0, lazy = 0;
} neutral1;
struct segtree1{
    segtree1 *left = nullptr, *right = nullptr;
    Node1 node = {};
    int start, end;
    segtree1(int l = 0, int r = 0) : start(l), end(r) {}

    void extend() {
        if (left == nullptr) {
            int mid = start + end >> 1;
            left = new segtree1(start, mid);
            right = new segtree1(mid + 1, end);
        }
    }
    Node1 pushup(Node1 a, Node1 b) {
        Node1 ret;
        ret.need = min(a.need, b.need);
        return ret;
    }
    void pushdown() {
        node.need += node.lazy;
        if (start != end) {
            extend();
            left->node.lazy += node.lazy;
            right->node.lazy += node.lazy;
        }
        node.lazy = 0;
    }

    void update(int l, int r, ll val) {
        pushdown();
        if (start > r || end < l)
            return;
        if (start >= l && end <= r) {
            node.lazy = val;
            pushdown();
            return;
        }
        extend();
        left->update(l, r, val);
        right->update(l, r, val);
        node = pushup(left->node, right->node);
    }
    void check(int l, int r) {
        pushdown();
        if (r < start || end < l || node.need > 0) return;
        if(start == end){
            B->update(start, end, A->query(start, end).val - node.need, 1);
            A->update(start, end, 1e17, 1);
            node.need = 1e17;
            return;
        }
        extend();
        left->check(l , r);
        right->check(l , r);
        node = pushup(left->node, right->node);
    }
    ~segtree1() {
        if (left == nullptr)return;
        delete left;
        delete right;
    }
}*seg;

void solve() {
    int n, q; cin >> n >> q;
    A = new segtree(0, n - 1);
    B = new segtree(0, n - 1);
    seg = new segtree1(0, n - 1);
    vector<int> a(n);
    for(auto& it : a) cin >> it;

    for(int i = 0; i < n; i++){
        A->update(i, i, a[i], 1);
        B->update(i, i, 1e17, 1);
        seg->update(i, i, a[i]);
    }
    while(q--){
        int t, l, r; cin >> t >> l >> r; l--; r--;
        if(t == 1){
            int x; cin >> x;
            B->update(l, r, x);
            seg->update(l, r, -x);
            seg->check(0, n - 1);
        }
        if(t == 2){
            cout << min(A->query(l, r).val, B->query(l, r).val) << '\n';
        }
    }

}

int main() {
    Speed();
    int tc = 1;
    //cin >> tc;
    while (tc--) {
        solve();
    }
    return 0;
}