#include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <set>
#include <map>

#define debug_value(x) cerr << "line" << __LINE__ << ":<" << __func__ << ">:" << #x << "=" << x << endl;
#define debug(x) cerr << "line" << __LINE__ << ":<" << __func__ << ">:" << x << endl;

using namespace std;
typedef long long ll;

struct node{
    ll n, cnt, inv;
};

node unit_node = (node){-100, -100, -100};

node merge_node(node a, node b){
    if(a.n == -100) return b;
    if(b.n == -100) return a;
    return (node){a.n+b.n, a.cnt+b.cnt, a.inv+b.inv+a.cnt*(b.n-b.cnt)};
}

node inv_node(node a){
    if(a.n == -100) return a;
    return (node){a.n, a.n-a.cnt, (a.cnt*(a.n-a.cnt))-a.inv};
}

template <typename T, typename S>
struct LazySegmentTree {
    int n;
    T unit;
    vector<T> node;
    vector<S> lazy;
    vector<bool> lazyFlag;

    T calc(T a, T b){
        T ans;
        ans = merge_node(a, b); //適宜変える
        return ans;
    }

    S calcLazy(S a, S b){
        S ans;
        ans = a^b; //適宜変える
        return ans;
    }

    S propagateLazy(S lazy1, S lazy2){
        return lazy1^lazy2; //適宜変える
    }

    T merge(T node, S lazy){
        if(lazy) return inv_node(node);
        return node; //適宜変える
    }

    S clearLazy(){
        return false; //適宜変える
    }

    LazySegmentTree(vector<T> v, T UNIT) {
        int sz = (int)v.size();
        unit = UNIT;
        n = 1; while(n < sz) n *= 2;
        node.resize(2*n-1, unit);
        lazy.resize(2*n-1, false);
        lazyFlag.resize(2*n-1, false);

        for(int i=0; i<sz; i++) node[i+n-1] = v[i];
        for(int i=n-2; i>=0; i--) node[i] = calc(node[i*2+1], node[i*2+2]);
    }

    void lazyEvaluate(int k, int l, int r) {
        if(lazyFlag[k]) {
            node[k] = merge(node[k], lazy[k]);
            if(r - l > 1) {
                lazy[k*2+1] = propagateLazy(lazy[k*2+1], lazy[k]);
                lazy[k*2+2] = propagateLazy(lazy[k*2+2], lazy[k]);
                lazyFlag[k*2+1] = lazyFlag[k*2+2] = true;
            }
            lazyFlag[k] = false;
            lazy[k] = clearLazy();
        }
    }

    //[a, b)
    //区間[a, b]への更新に対してはupdate(a, b+1, x)と呼ぶ
    void update(int a, int b, S x, int k=0, int l=0, int r=-1) {
        if(r < 0) r = n;
        lazyEvaluate(k, l, r);
        if(b <= l || r <= a) return;
        if(a <= l && r <= b) {
            lazy[k] = calcLazy(lazy[k], x);
            lazyFlag[k] = true;
            lazyEvaluate(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] = calc(node[2*k+1], node[2*k+2]);
        }
    }

    //[a, b)
    //区間[a, b]へのクエリに対してはquery(a, b+1)と呼ぶ
    T query(int a, int b, int k=0, int l=0, int r=-1) {
        if(r < 0) r = n;
        lazyEvaluate(k, l, r);
        if(b <= l || r <= a) return unit;
        if(a <= l && r <= b) return node[k];
        T vl = query(a, b, 2*k+1, l, (l+r)/2);
        T vr = query(a, b, 2*k+2, (l+r)/2, r);
        return calc(vl, vr);
    }
};

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << setprecision(10) << fixed;
    int N, Q; cin >> N >> Q;
    vector<node> v;
    for(int i = 0; i < N; i++){
        int a; cin >> a;
        if(a == 0){
            node n = (node){1, 0, 0};
            v.push_back(n);
        }else{
            node n = (node){1, 1, 0};
            v.push_back(n);
        }
    }
    LazySegmentTree<node, bool> sgt(v, unit_node);
    
    for(int i = 0; i < Q; i++){
        int t, l, r; cin >> t >> l >> r;
        if(t == 1){
            sgt.update(l-1, r, true);
        }else{
            cout << sgt.query(l-1, r).inv << endl;
        }
    }
}

Measured memory_bytes: 25004