#include <bits/stdc++.h>
#define int long long

using namespace std;

const int INF = 1e9;
int n, m, k;
vector <vector <int>> a;
vector <int> sm;
vector <bool> is_reversed;
vector <int> h, a1, a2;

void result() {
    for (int i = 0; i < a.size(); i++) {
        for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
        cout << "\n";
    }
    cout << "\n";
}

void split(int i) {
    h.resize(a[i].size() - k);
    copy(a[i].begin() + k, a[i].end(), h.begin());
    a.insert(a.begin() + i + 1, h);
    sm.insert(sm.begin() + i + 1, 0);
    is_reversed.insert(is_reversed.begin() + i + 1, false);
    for (int j = 0; j < h.size(); j++) {
        sm[i] -= a[i + 1][j];
        sm[i + 1] += a[i + 1][j];
    }
    a[i].resize(k);
}

void swap_(int l1, int r1, int i1, int l2, int r2, int i2) {
    a1.resize(l1 + r2 + 1);
    a2.resize(a[i1].size() - l1 + a[i2].size() - r2 - 1);
    copy(a[i1].begin(), a[i1].begin() + l1, a1.begin());
    copy(a[i2].begin(), a[i2].begin() + r2 + 1, a1.begin() + l1);
    copy(a[i1].begin() + l1, a[i1].end(), a2.begin());
    copy(a[i2].begin() + r2 + 1, a[i2].end(), a2.begin() + a[i1].size() - l1);
    swap(a[i1], a1);
    swap(a[i2], a2);
    a1.clear();
    a2.clear();
}

int sum(int l, int r, int i) {
    int res = 0;
    for (int j = l; j <= r; j++) res += a[i][j];
    return res;
}

void apply(int i) {
    if (is_reversed[i]) reverse(a[i].begin(), a[i].end());
    is_reversed[i] = false;
}

void reverse_(int l, int r) {
    int l0 = 0, r0, ft = INF, lt = 0, pos_ft, pos_lt;
    for (int i = 0; i < a.size(); i++) {
        r0 = l0 + a[i].size() - 1;
        if (!(r < l0 || r0 < l)) {
            if (i < ft) {
                ft = i;
                pos_ft = l0;
            }
            lt = i;
            pos_lt = l0;
            is_reversed[i] = !is_reversed[i];
        }
        l0 = r0 + 1;
    }
    if (ft - lt == 0) {
        is_reversed[ft] = !is_reversed[ft];
        apply(ft);
        reverse(a[ft].begin() + l - pos_ft, a[ft].begin() + r - pos_ft + 1);
    }
    else {
        is_reversed[ft] = !is_reversed[ft];
        is_reversed[lt] = !is_reversed[lt];
        apply(ft);
        apply(lt);
        int l1 = l - pos_ft, r1 = a[ft].size() - 1;
        int l2 = 0, r2 = r - pos_lt;
        int smft = sum(l1, r1, ft);
        int smlt = sum(l2, r2, lt);
        sm[ft] += smlt - smft;
        sm[lt] += smft - smlt;
        reverse(a[ft].begin() + l1, a[ft].begin() + r1 + 1);
        reverse(a[lt].begin() + l2, a[lt].begin() + r2 + 1);
        swap_(l1, r1, ft, l2, r2, lt);
        if (a[ft].size() >= 2 * k) split(ft);
        if (a[lt].size() >= 2 * k) split(lt);
    }
    if (ft - lt > 3) {
        reverse(a.begin() + ft + 1, a.begin() + lt);
        reverse(sm.begin() + ft + 1, sm.begin() + lt);
    }
}

int ans(int l, int r) {
    int l0 = 0, r0, res = 0;
    for (int i = 0; i < a.size(); i++) {
        r0 = l0 + a[i].size() - 1;
        if (l <= l0 && r0 <= r) res += sm[i];
        else if (!(r < l0 || r0 < l)) {
            apply(i);
            res += sum(max(l, l0) - l0, min(r, r0) - l0, i);
        }
        l0 += a[i].size();
    }
    return res;
}

signed main() {
    cin >> n >> m;
    k = sqrt(n);
    a.resize((n - 1) / k + 1);
    sm.assign((n - 1) / k + 1, 0);
    is_reversed.assign((n - 1) / k + 1, false);
    for (int i = 0; i < n; i++) {
        int ai;
        cin >> ai;
        a[i / k].push_back(ai);
        sm[i / k] += ai;
    }
    //result();
    for (int _ = 0; _ < m; _++) {
        int type, l, r;
        cin >> type >> l >> r;
        l--;
        r--;
        if (type) reverse_(l, r);
        else cout << ans(l, r) << "\n";
        //result();
    }
}