#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using namespace atcoder;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)

#define int long long
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, Q;
    cin >> N >> Q;
    assert(1 <= N && N <= 100000);
    assert(1 <= Q && Q <= 100000);
    
    vector<int> A(N);
    rep(i, N) {
        cin >> A[i];
        assert(0 <= A[i] && A[i] <= 100000);
    }
    
    int rN = (int)(sqrtl(N) + 0.5);
    int rQ = (int)(sqrtl(Q) + 0.5);
    
    vector<vector<tuple<int, int, int, int, int>>> queries((Q + rQ - 1) / rQ);
    rep(q, Q) {
        int t;
        cin >> t;
        assert(t == 1 || t == 2);
        
        if (t == 1) {
            int x, y;
            cin >> x >> y;
            assert(1 <= x && x <= N);
            assert(0 <= y && y <= 100000);
            --x;
            
            queries[q / rQ].emplace_back(t, x, y, -1, -1);
        } else {
            int l, r, a, b;
            cin >> l >> r >> a >> b;
            assert(1 <= l && l <= r && r <= N);
            assert(0 <= a && a <= 100000);
            assert(0 <= b && b <= 100000);
            --l;
            
            queries[q / rQ].emplace_back(t, l, r, a, b);
        }
    }
    
    for (auto& block : queries) {
        vector<int> ans(block.size());
        
        vector<tuple<int, int, int, int, int>> events;
        rep(i, N) events.emplace_back(A[i], i, -1, -1, -1);
        rep(q, block.size()) {
            auto [t, l, r, a, b] = block[q];
            if (t == 1) continue;
            
            events.emplace_back(a, l, r, q, 0);
            events.emplace_back(b, l, r, q, 1);
        }
        sort(events.begin(), events.end());
        
        auto sum_query = [rN](vector<int>& block, vector<int>& sum, int l, int r) -> int {
            int res = 0;
            int bl = (l + rN - 1) / rN, br = r / rN;
            
            if (br < bl) {
                for (int i = l; i < r; ++i) res += sum[i];
            } else {
                for (int i = bl; i < br; ++i) res += block[i];
                for (int i = l; i < bl * rN; ++i) res += sum[i];
                for (int i = br * rN; i < r; ++i) res += sum[i];
            }
            return res;
        };
        vector<int> sum0(N), sum1(N);
        vector<int> bsum0((N + rN - 1) / rN), bsum1((N + rN - 1) / rN);
        for (auto [x, l, r, q, t] : events) {
            if (t == -1) {
                sum0[l] += 1;
                sum1[l] += x;
                bsum0[l / rN] += 1;
                bsum1[l / rN] += x;
            } else if (t == 0) {
                ans[q] -= sum_query(bsum1, sum1, l, r);
                ans[q] += sum_query(bsum0, sum0, l, r) * x;
            } else {
                ans[q] += sum_query(bsum1, sum1, l, r);
                ans[q] += (r - l - sum_query(bsum0, sum0, l, r)) * x;
            }
        }
        
        unordered_map<int, int> update_history;
        rep(q, block.size()) {
            auto [t, l, r, a, b] = block[q];
            if (t == 1) {
                int x = l;
                int y = r;
                
                update_history[x] = y;
            } else {
                if (a > b) {
                    cout << a * (r - l) << '\n';
                    continue;
                }
                
                for (auto [i, x] : update_history) {
                    if (l <= i && i < r) {
                        ans[q] -= clamp(A[i], a, b);
                        ans[q] += clamp(x, a, b);
                    }
                }
                cout << ans[q] << '\n';
            }
        }
        
        for (auto [i, x] : update_history) {
            A[i] = x;
        }
    }
}