#ifndef SorahISA
#define SorahISA
#include SorahISA __FILE__ SorahISA

const int INF = 1E9 + 10;

struct SegBeats {
    
    struct Node {
        int min1, min2, min_cnt, pmax, pmax_id, smax, smax_id, mss, sum, tag;
        Node() : min1(INF), min2(INF), min_cnt(0), pmax(0), pmax_id(-1), smax(0), smax_id(0), mss(0), sum(0), tag(-INF) {}
        Node(int val, int id) :
            min1(val), min2(INF), min_cnt(1),
            pmax(val >= 0 ? val : 0), pmax_id(val >= 0 ? id : id-1),
            smax(val >= 0 ? val : 0), smax_id(val >= 0 ? id : id+1),
            mss(val >= 0 ? val : 0), sum(val), tag(-INF) {}
    };
    
    vector<Node> seg;
    int maxn;
    
    void init(int N, const vector<int> &vec) {
        maxn = (1 << (__lg(N+1) + 1));
        seg.assign(2*maxn, Node());
        for (int i = 0; i < maxn; ++i) seg[i+maxn] = Node((i < SZ(vec) ? vec[i] : 0), i);
        for (int i = maxn-1; i >= 1; --i) pull(seg[i], seg[i<<1], seg[i<<1|1]);
    }
    
    void push(Node &a, Node &l, Node &r) {
        if (a.tag > l.min1) {
            l.sum += (a.tag - l.min1) * l.min_cnt;
            l.min1 = l.tag = a.tag;
        }
        if (a.tag > r.min1) {
            r.sum += (a.tag - r.min1) * r.min_cnt;
            r.min1 = r.tag = a.tag;
        }
        a.tag = -INF;
    }
    
    void pull(Node &a, Node &l, Node &r) {
        a.min1 = min(l.min1, r.min1);
        a.min2 = (l.min1 == r.min1 ? min(l.min2, r.min2) : (l.min1 < r.min1 ? min(l.min2, r.min1) : min(l.min1, r.min2)));
        a.min_cnt = l.min_cnt * (l.min1 == a.min1) + r.min_cnt * (r.min1 == a.min1);
        a.pmax = max(l.pmax, l.sum + r.pmax);
        a.pmax_id = (l.pmax == a.pmax ? l.pmax_id : r.pmax_id);
        a.smax = max(r.smax, r.sum + l.smax);
        a.smax_id = (r.smax == a.smax ? r.smax_id : l.smax_id);
        a.mss = max({l.mss, r.mss, l.smax + r.pmax});
        a.sum = l.sum + r.sum;
        a.tag = -INF;
    }
    
    Node query_node(int qL, int qR) { return query_node(qL, qR, 1, 0, maxn-1); }
    Node query_node(int qL, int qR, int now, int nL, int nR) {
        if (qL <= nL and nR <= qR) return seg[now];
        
        push(seg[now], seg[now<<1], seg[now<<1|1]);
        
        int nM = (nL + nR) >> 1;
        
        Node tmp, l, r;
        if (qL <= nM) l = query_node(qL, qR, now<<1,   nL,   nM);
        if (nM <  qR) r = query_node(qL, qR, now<<1|1, nM+1, nR);
        pull(tmp, l, r);
        
        pull(seg[now], seg[now<<1], seg[now<<1|1]);
        
        return tmp;
    }
    
    void modify_range_chmax(int qL, int qR, int val) { return modify_range_chmax(qL, qR, val, 1, 0, maxn-1); }
    void modify_range_chmax(int qL, int qR, int val, int now, int nL, int nR) {
        if (qL <= nL and nR <= qR and val <= seg[now].min1) return;
        if (qL <= nL and nR <= qR and val < seg[now].min2) {
            seg[now].sum += (val - seg[now].min1) * seg[now].min_cnt;
            seg[now].min1 = seg[now].tag = val;
            
            // while (seg[now].pmax_id < nR) {
            //     if (query_node(seg[now].pmax_id + 1, nR, now, nL, nR).pmax > 0) ++seg[now].pmax_id;
            //     else break;
            // }
            if (seg[now].pmax_id < nR) seg[now].pmax_id = query_node(seg[now].pmax_id + 1, nR, now, nL, nR).pmax_id;
            if (seg[now].pmax_id == nR) seg[now].pmax = seg[now].sum;
            else seg[now].pmax = (nL <= seg[now].pmax_id ? query_node(nL, seg[now].pmax_id, now, nL, nR).sum : 0);
            
            // while (seg[now].smax_id > nL) {
            //     if (query_node(nL, seg[now].smax_id - 1, now, nL, nR).smax > 0) --seg[now].smax_id;
            //     else break;
            // }
            if (seg[now].smax_id > nL) seg[now].smax_id = query_node(nL, seg[now].smax_id - 1, now, nL, nR).smax_id;
            if (seg[now].smax_id == nL) seg[now].smax = seg[now].sum;
            else seg[now].smax = (nR >= seg[now].smax_id ? query_node(seg[now].smax_id, nR, now, nL, nR).sum : 0);
            
            return;
        }
        
        push(seg[now], seg[now<<1], seg[now<<1|1]);
        
        int nM = (nL + nR) >> 1;
        if (qL <= nM) modify_range_chmax(qL, qR, val, now<<1,   nL,   nM);
        if (nM <  qR) modify_range_chmax(qL, qR, val, now<<1|1, nM+1, nR);
        
        pull(seg[now], seg[now<<1], seg[now<<1|1]);
    }
    
};

void solve() {
    int N, Q; cin >> N >> Q;
    
    vector<int> A(N);
    for (int &x : A) cin >> x;
    
    SegBeats seg; seg.init(N, A);
    
    for (int q = 1; q <= Q; ++q) {
        int op; cin >> op;
        if (op == 0) {
            int l, r, x; cin >> l >> r >> x, --l, --r;
            seg.modify_range_chmax(l, r, x);
        }
        if (op == 1) {
            int l, r; cin >> l >> r, --l, --r;
            print(seg.query_node(l, r).mss);
        }
    }
}

int32_t main() {
    fastIO();
    
    int t = 1; // cin >> t;
    for (int _ = 1; _ <= t; ++_) {
        // cout << "Case #" << _ << ": ";
        solve();
    }
    
    return 0;
}

#else

#ifdef local
#define _GLIBCXX_DEBUG 1
#endif
#pragma GCC optimize("Ofast", "unroll-loops")
#include <bits/stdc++.h>
#include <bits/extc++.h>
using namespace std;

#define int int64_t
// #define double __float80
using pii = pair<int, int>;
template <typename T> using Prior = std::priority_queue<T>;
template <typename T> using prior = std::priority_queue<T, vector<T>, greater<T>>;

// #define X first
// #define Y second
#define eb emplace_back
#define ef emplace_front
#define ee emplace
#define pb pop_back
#define pf pop_front
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define SZ(x) ((int)(x).size())

template <size_t D, typename T> struct Vec : vector<Vec<D-1, T>> {
    static_assert(D >= 1, "Vector dimension must be greater than zero!");
    template <typename... Args> Vec(int n = 0, Args... args) : vector<Vec<D-1, T>>(n, Vec<D-1, T>(args...)) {}
};

template <typename T> struct Vec<1, T> : vector<T> {
    Vec(int n = 0, const T& val = T()) : vector<T>(n, val) {}
};

template <class F>
inline constexpr decltype(auto) lambda_fix(F&& f) {
    return [f = std::forward<F>(f)](auto&&... args) {
        return f(f, std::forward<decltype(args)>(args)...);
    };
}

#ifdef local
#define fastIO() void()
#define debug(...) \
    _color.emplace_back("\u001b[31m"), \
    fprintf(stderr, "%sAt [%s], line %d: (%s) = ", _color.back().c_str(), __FUNCTION__, __LINE__, #__VA_ARGS__), \
    _do(__VA_ARGS__), _color.pop_back(), \
    fprintf(stderr, "%s", _color.back().c_str())
#define print(...) \
    fprintf(stdout, "%s", "\u001b[36m"), \
    _P(__VA_ARGS__), \
    fprintf(stdout, "%s", "\u001b[0m")

deque<string> _color{"\u001b[0m"};

template <typename T> concept is_string = is_same_v<T, string&> or is_same_v<T, const string&>;
template <typename T> concept is_iterable = requires (T _t) {begin(_t);};

template <typename T> inline void _print_err(T &&_t);
template <typename T> inline void _print_err(T &&_t) requires is_iterable<T> and (not is_string<T>);
template <size_t I, typename ...U> inline typename enable_if<I == sizeof...(U), void>::type _print_err(const tuple<U...> &);
template <size_t I, typename ...U> inline typename enable_if<I <  sizeof...(U), void>::type _print_err(const tuple<U...> &_t);
template <size_t I, typename ...U> inline typename enable_if<I == sizeof...(U), void>::type _print_err(tuple<U...> &);
template <size_t I, typename ...U> inline typename enable_if<I <  sizeof...(U), void>::type _print_err(tuple<U...> &_t);
template <typename T, typename U> ostream& operator << (ostream &os, const pair<T, U> &_tu);

inline void _do() {cerr << "\n";};
template <typename T> inline void _do(T &&_t) {_print_err(_t), cerr << "\n";}
template <typename T, typename ...U> inline void _do(T &&_t, U &&..._u) {_print_err(_t), cerr << ", ", _do(_u...);}
#else
#define fastIO() ios_base::sync_with_stdio(0), cin.tie(0)
#define debug(...) void()
#define print(...) _P(__VA_ARGS__)
#endif

inline void _P() {cout << "\n";};
template <typename T> inline void _P(T &&_t) {cout << _t << "\n";}
template <typename T, typename ...U> inline void _P(T &&_t, U &&..._u) {cout << _t << " ", _P(_u...);}

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int getRand(int L, int R) {
    if (L > R) swap(L, R);
    return (int)(rng() % ((uint64_t)R - L + 1) + L);
}

template <typename T, typename U> bool chmin(T &lhs, U rhs) {return lhs > rhs ? lhs = rhs, 1 : 0;}
template <typename T, typename U> bool chmax(T &lhs, U rhs) {return lhs < rhs ? lhs = rhs, 1 : 0;}

/// below are Fast I/O and _print_err templates ///

/*
/// Fast I/O by FHVirus ///
/// https://fhvirus.github.io/blog/2020/fhvirus-io/ ///

#include <unistd.h>

const int S = 65536;

int OP = 0;
char OB[S];

inline char RC() {
    static char buf[S], *p = buf, *q = buf;
    return p == q and (q = (p = buf) + read(0, buf, S)) == buf ? -1 : *p++;
}

inline int RI() {
    static char c;
    int a;
    while (((c = RC()) < '0' or c > '9') and c != '-' and c != -1);
    if (c == '-') {
        a = 0;
        while ((c = RC()) >= '0' and c <= '9') a *= 10, a -= c ^ '0';
    }
    else {
        a = c ^ '0';
        while ((c = RC()) >= '0' and c <= '9') a *= 10, a += c ^ '0';
    }
    return a;
}

inline void WI(int n, char c = '\n') {
    static char buf[20], p;
    if (n == 0) OB[OP++] = '0';
    p = 0;
    if (n < 0) {
        OB[OP++] = '-';
        while (n) buf[p++] = '0' - (n % 10), n /= 10;
    }
    else {
        while (n) buf[p++] = '0' + (n % 10), n /= 10;
    }
    for (--p; p >= 0; --p) OB[OP++] = buf[p];
    OB[OP++] = c;
    if (OP > S-20) write(1, OB, OP), OP = 0;
}

/// Fast I/O by FHVirus ///
/// https://fhvirus.github.io/blog/2020/fhvirus-io/ ///
*/

#ifdef local

template <typename T> inline void _print_err(T &&_t) {cerr << _t;}

template <typename T> inline void _print_err(T &&_t) requires is_iterable<T> and (not is_string<T>) {
    string _tmp_color = _color.back();
    ++_tmp_color[3], _color.emplace_back(_tmp_color);
    cerr << _color.back() << "[";
    for (bool _first = true; auto &_x : _t) {
        if (!_first) cerr << ", ";
        _print_err(_x), _first = false;
    }
    cerr << "]" << (_color.pop_back(), _color.back());
}

template <typename T, typename U> ostream& operator << (ostream &os, const pair<T, U> &_tu) {
    string _tmp_color = _color.back();
    ++_tmp_color[3], _color.emplace_back(_tmp_color);
    cerr << _color.back() << "(";
    _print_err(_tu.first), cerr << ", ", _print_err(_tu.second);
    cerr << ")" << (_color.pop_back(), _color.back());
    return os;
}

template <size_t I = 0, typename ...U> inline typename enable_if<I == sizeof...(U), void>::type _print_err(const tuple<U...> &) {
    cerr << ")" << (_color.pop_back(), _color.back());
}

template <size_t I = 0, typename ...U> inline typename enable_if<I <  sizeof...(U), void>::type _print_err(const tuple<U...> &_t) {
    if (!I) {
        string _tmp_color = _color.back();
        ++_tmp_color[3], _color.emplace_back(_tmp_color);
        cerr << _color.back();
    }
    cerr << (I ? ", " : "("), _print_err(get<I>(_t)), _print_err<I+1, U...>(_t);
}

template <size_t I = 0, typename ...U> inline typename enable_if<I == sizeof...(U), void>::type _print_err(tuple<U...> &) {
    cerr << ")" << (_color.pop_back(), _color.back());
}

template <size_t I = 0, typename ...U> inline typename enable_if<I <  sizeof...(U), void>::type _print_err(tuple<U...> &_t) {
    if (!I) {
        string _tmp_color = _color.back();
        ++_tmp_color[3], _color.emplace_back(_tmp_color);
        cerr << _color.back();
    }
    cerr << (I ? ", " : "("), _print_err(get<I>(_t)), _print_err<I+1, U...>(_t);
}

#endif

#endif