#include <bits/stdc++.h>

using namespace std;

#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)

typedef int64_t ll;

ll INF = (1 << 31) - 1;

int get_n(int n) {
    int ret = 1; while(ret < n) ret <<= 1;

    return ret;
}

struct SegTree {
    int N;
    vector<ll> dat;

    explicit SegTree(int n): N(get_n(n)), dat(2*N-1, INF) {}
    explicit SegTree(const vector<ll> & v) {
        N = get_n(v.size());
        dat.resize(2*N - 1, INF);

        REP(i, v.size()) dat[N + i - 1] = v[i];
        for (int i=N-2; i > -1; --i) dat[i] = _op(dat[2*i + 1], dat[2*i + 2]);
    }

    ll _op(ll a, ll b) {
        return min(a, b);
    }

    ll _up(ll& a, ll b) {
        a = b;
    }

    void update(int i, ll v) {
        i += N - 1;
        _up(dat[i], v);

        while(i > 0) {
            i = (i - 1) / 2;
            dat[i] = _op(dat[2*i + 1], dat[2*i + 2]);
        }
    }

    // query for [a, b), k: current node id, [l, r): current range.
    ll query(int a, int b, int k=0, int l=0, int r=-1) {
        if (r < 0) r = N;

        if (b <= l || r <= a) return INF;
        if (a <= l && r <= b) return dat[k];

        int mid = (l + r) / 2;
        ll c1 = query(a, b, 2*k + 1, l, mid);
        ll c2 = query(a, b, 2*k + 2, mid, r);

        return _op(c1, c2);
    }
};

//template <typename T>
//struct LazySegTree {
//    int N;
//    vector<T> dat;
//    vector<T> lazy;
//
//    explicit LazySegTree(int n): N(get_n(n)), dat(2*N-1, 0), lazy(2*N-1, 0) {}
//    explicit LazySegTree(const vector<ll>& v) {
//        N = get_n(v.size());
//        dat.resize(2 * N - 1);
//        lazy.resize(2 * N - 1, 0);
//
//        REP(i, N) dat[N + i - 1] = v[i];
//        for (int i = N-2; i > -1; --i) dat[i] = _op(dat[2*i + 1], dat[2*i + 2]);
//    }
//
//    ll _op(ll a, ll b) {
//        return a + b;
//    }
//
//    void eval(int k, int l, int r) {
//        if (lazy[k] == 0) return;
//
//        dat[k] += lazy[k];
//
//        if(r - l > 1) {
//            lazy[2*k+1] += lazy[k] / 2;
//            lazy[2*k+2] += lazy[k] / 2;
//        }
//
//        lazy[k] = 0;
//    }
//
//    void update(int a, int b, int v, int k=0, int l=0, int r=-1) {
//        if(r < 0) r = N;
//
//        if (b <= l || r <= a) return;
//
//        eval(k, l, r);
//
//        if (a <= l && r <= b) {
//            lazy[k] += (r - l) * v ;
//            return;
//        }
//
//        int mid = (l + r) / 2;
//        update(a, b, v, 2 * k + 1, l, mid);
//        update(a, b, v, 2 * k + 2, mid, r);
//        dat[k] = _op(dat[2*k+1], dat[2*k+2]);
//    }
//
//    ll query(int a, int b, int k=0, int l=0, int r=-1) {
//        if(r < 0) r = N;
//
//        if (b <= l || r <= a) return 0;
//
//        eval(k, l, r);
//
//        if(a <= l && r <= b) return dat[k];
//
//        int mid = (l + r) / 2;
//        ll c1 = query(a, b, 2 * k + 1, l, mid);
//        ll c2 = query(a, b, 2 * k + 2, mid, r);
//        return _op(c1, c2);
//    }
//};

// RSQ
template<typename T>
struct LSQ_LazySegTree {
    int N;
    vector<T> dat, lazy;

    explicit LSQ_LazySegTree(int n): N(get_n(n)), dat(2*N-1, 0), lazy(2*N-1, 0) {}

    // add v to [a, b), current range: [l, r), node id: k
    void add (int a, int b, T v, int k = 0, int l = 0, int r = -1) {
        if (r < 0) r = N;

        if (r <= a || b <= l) return;

        if (a <= l && r <= b) {
            lazy[k] += v; //
            return;
        }

        dat[k] += v * (min(b, r) - max(a, l)); //
        int mid = (l + r) / 2;
        add(a, b, v, 2 * k + 1, l, mid);
        add(a, b, v, 2 * k + 2, mid, r);
    }

    T sum(int a, int b, int k = 0, int l = 0, int r = -1) {
        if (r < 0) r = N;

        if (r <= a || b <= l) return 0;

        if (a <= l && r <= b) {
            return dat[k] + lazy[k] * (r - l); //
        }

        T ret = lazy[k] * (min(b, r) - max(a, l)); //
        int mid = (l + r) / 2;
        ret += sum(a, b, 2 * k + 1, l, mid); //
        ret += sum(a, b, 2 * k + 2, mid, r); //

        return ret;
    }
};

// starry sky tree
template<typename T>
struct LMQ_LazySegTree {
    int N;
    vector<T> dat, lazy;

    explicit LMQ_LazySegTree(int n): N(get_n(n)), dat(2*N-1, 0), lazy(2*N-1, 0) {}

    // add v to [a, b), current range: [l, r), node id: k
    void add (int a, int b, T v, int k = 0, int l = 0, int r = -1) {
        if (r < 0) r = N;

        if (r <= a || b <= l) return;

        if (a <= l && r <= b) {
            lazy[k] += v;
            return;
        }

        int mid = (l + r) / 2;
        add(a, b, v, 2 * k + 1, l, mid);
        add(a, b, v, 2 * k + 2, mid, r);

        dat[k] = min(dat[2*k+1] + lazy[2*k+1], dat[2*k+2] + lazy[2*k+2]);
    }

    T query(int a, int b, int k = 0, int l = 0, int r = -1) {
        if (r < 0) r = N;

        if (r <= a || b <= l) return INF;

        if (a <= l && r <= b) {
            return dat[k] + lazy[k];
        }

        int mid = (l + r) / 2;
        T m1 = query(a, b, 2 * k + 1, l, mid);
        T m2 = query(a, b, 2 * k + 2, mid, r);

        return min(m1, m2) + lazy[k];
    }
};


// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_A&lang=jp
int aoj_dsl_2a() {
    int n, q;
    cin >> n >> q;

    INF = (1 << 31) - 1;

    SegTree st(n);

    REP(_, q) {
        int c, x, y;
        cin >> c >> x >> y;

        if (c == 0) st.update(x, y);
        else cout << st.query(x, y+1) << endl;
    }

}

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_G&lang=jp
int aoj_dsl_2g() {
    int n, q;
    cin >> n >> q;

    LSQ_LazySegTree<ll> lst(n);

    REP(_, q) {
        int o, s, t;
        cin >> o >> s >> t;
        --s; --t;

        if (o == 0) {
            int x;
            cin >> x;
            lst.add(s, t + 1, x);
        } else {
            cout << lst.sum(s, t + 1) << endl;
        }
    }
}

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

    LMQ_LazySegTree<ll> lst(n);

    REP(_, q) {
        int o, s, t;
        cin >> o >> s >> t;

//        cout << "[" << _ << "]" << endl;

        if (o == 0) {
            int x;
            cin >> x;
            lst.add(s, t + 1, x);
//
//            int c = 0, d = 1;
//            cout << "### dat ###" << endl;
//            REP(i, lst.dat.size()) {
//                if (c == d) {
//                    cout << endl;
//                    c = 0; d <<= 1;
//                }
//                cout << lst.dat[i] << " ";
//                c++;
//            }
//            cout << endl;
//
//            c = 0, d = 1;
//            cout << "### lazy ###" << endl;
//            REP(i, lst.lazy.size()) {
//                if (c == d) {
//                    cout << endl;
//                    c =0; d <<= 1;
//                }
//                cout << lst.lazy[i] << " ";
//                c++;
//            }
//            cout << endl;

        } else {
            cout << lst.query(s, t + 1) << endl;
        }
    }
}




Measured memory_bytes: 7088