/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author tatsumack
 */

#include <iostream>
#include <fstream>

#include <iostream>
#include <limits.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>

#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <queue>
#include <unordered_map>
#include <unordered_set>

#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF 1001001001001001001ll
#define fcout cout << fixed << setprecision(12)

using namespace std;

typedef pair<int, int> P;

struct data {
    int odd, even, sum;
};

struct query {
    int sum, swap, upd;

    bool operator==(query rhs) {
        return sum == rhs.sum && rhs.swap == swap && upd == rhs.upd;
    }
};

template<typename T, typename S>
struct LazySegmentTree {
private:
    int n;
    vector<T> node;
    vector<S> lazy;
    T E0;
    S E1;

    inline void updatef(S& lazy, S& value) {
        if (value.sum == -1) {
            lazy.sum = -1;
            lazy.swap ^= value.swap;
            lazy.upd |= value.upd;
        } else {
            if (lazy.sum == -1 || value.upd)lazy.sum = 0;
            lazy.sum += value.sum;
            lazy.swap ^= value.swap;
            lazy.upd |= value.upd;
        }
    }

    inline void calculatef(T& node, S& lazy, int len) {
        if (lazy.sum == -1) {
            if (lazy.swap)swap(node.odd, node.even);
            node.sum = node.odd;
        } else {
            if (lazy.swap)swap(node.odd, node.even);
            if (lazy.upd) {
                if (lazy.sum % 2 == 0)node.sum = node.odd;
                else node.sum = node.even;
            }
            node.sum += lazy.sum * len;
        }

    }

    inline T queryf(T& x, T& y) {
        return {x.odd + y.odd, x.even + y.even, x.sum + y.sum};
    }

public:
    LazySegmentTree(int sz, T nodeE, S lazyE) : E0(nodeE), E1(lazyE) {
        n = 1;
        while (n < sz)n <<= 1;
        node.resize(2 * n - 1, E0);
        lazy.resize(2 * n - 1, E1);
    }

    LazySegmentTree(vector<T>& v, T E0, S E1) : E0(E0), E1(E1) {
        n = 1;
        int sz = v.size();
        while (n < sz)n <<= 1;
        node.resize(2 * n - 1, E0);
        lazy.resize(2 * n - 1, E1);
        REP(i, sz)node[i + n - 1] = v[i];
        for (int i = n - 2; i >= 0; --i) {
            node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
        }
    }

    void eval(int k, int l, int r) {
        if (lazy[k] == E1)return;
        calculatef(node[k], lazy[k], r - l);
        if (r - l > 1) {
            updatef(lazy[2 * k + 1], lazy[k]);
            updatef(lazy[2 * k + 2], lazy[k]);
        }
        lazy[k] = E1;
    }

    void update(int a, int b, S x, int k = 0, int l = 0, int r = -1) {
        if (r < 0)r = n;
        eval(k, l, r);
        if (r <= a || b <= l)return;
        if (a <= l && r <= b) {
            updatef(lazy[k], x);
            eval(k, l, r);
        } else {
            update(a, b, x, 2 * k + 1, l, (l + r) / 2);
            update(a, b, x, 2 * k + 2, (l + r) / 2, r);
            node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
        }
    }

    T query(int a, int b, int k = 0, int l = 0, int r = -1) {
        if (r < 0)r = n;
        eval(k, l, r);
        if (r <= a || b <= l)return E0;
        if (a <= l && r <= b)return node[k];
        T xl = query(a, b, 2 * k + 1, l, (l + r) / 2);
        T xr = query(a, b, 2 * k + 2, (l + r) / 2, r);
        return queryf(xl, xr);
    }
};


class RangeMod2Query {
public:
    static constexpr int kStressIterations = 0;

    static void generateTest(std::ostream& test) {
    }

    void solve(std::istream& cin, std::ostream& cout) {
        int N, Q;
        cin >> N >> Q;
        vector<data> A;
        REP(i, N) {
            int x;
            cin >> x;
            if (x & 1) {
                A.push_back({1, 0, x});
            } else {
                A.push_back({0, 1, x});
            }
        }

        LazySegmentTree<data, query> seg(A, {0, 0, 0}, {0, 0, 0});
        while (Q--) {
            int t;
            cin >> t;
            int l, r;
            cin >> l >> r;
            if (t == 1) {
                seg.update(l - 1, r, {-1, 0, 1});
            } else if (t == 2) {
                int x;
                cin >> x;
                seg.update(l - 1, r, {x, x & 1, 0});
            } else {
                cout << seg.query(l - 1, r).sum << endl;
            }
        }
    }
};


signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    std::istream& in(std::cin);
    std::ostream& out(std::cout);

    RangeMod2Query solver;
    solver.solve(in, out);
    return 0;
}