#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 10;
int a[N];

struct node {
    int l, r;
    int sum, change, yihuo;
    int tot1, lt1, rt1;
    int tot2, lt2, rt2;
} tr[N * 4];

void pushup(node &u, node &l, node &r) {
    u.sum = l.sum + r.sum;
    if (l.lt1 == l.r - l.l + 1) {
        u.lt1 = r.lt1 + l.lt1;
    } else {
        u.lt1 = l.lt1;
    }
    if (l.lt2 == l.r - l.l + 1) {
        u.lt2 = r.lt2 + l.lt2;
    } else {
        u.lt2 = l.lt2;
    }
    if (r.rt1 == r.r - r.l + 1) {
        u.rt1 = r.rt1 + l.rt1;
    } else {
        u.rt1 = r.rt1;
    }
    if (r.rt2 == r.r - r.l + 1) {
        u.rt2 = r.rt2 + l.rt2;
    } else {
        u.rt2 = r.rt2;
    }
    u.tot1 = max({l.rt1 + r.lt1, max(l.tot1, r.tot1), max(u.lt1, u.rt1)});
    u.tot2 = max({l.rt2 + r.lt2, max(l.tot2, r.tot2), max(u.lt2, u.rt2)});
}

void pushup(int u) { pushup(tr[u], tr[u * 2], tr[u * 2 + 1]); }

void build(int u, int l, int r) {
    if (l == r) {
        int x1 = (a[r] == 1);
        int x2 = (a[r] == 0);
        tr[u] = {l, r, a[r], -1, 0, x1, x1, x1, x2, x2, x2};
    } else {
        tr[u] = {l, r, 0, -1, 0};
        int mid = (l + r) / 2;
        build(u * 2, l, mid);
        build(u * 2 + 1, mid + 1, r);
        pushup(u);
    }
}

void pushdown(int x) {
    node &u = tr[x], &l = tr[x * 2], &r = tr[x * 2 + 1];
    if (u.change != -1) {
        u.change ^= u.yihuo;
        u.yihuo = 0;
        l.change = u.change;
        r.change = u.change;
        l.sum = (l.r - l.l + 1) * u.change;
        r.sum = (r.r - r.l + 1) * u.change;
        if (u.change == 0) {
            l.lt2 = l.rt2 = l.tot2 = (l.r - l.l + 1);
            r.lt2 = r.rt2 = r.tot2 = (r.r - r.l + 1);
            l.lt1 = l.rt1 = l.tot1 = 0;
            r.lt1 = r.rt1 = r.tot1 = 0;
        } else {
            l.lt1 = l.rt1 = l.tot1 = (l.r - l.l + 1);
            r.lt1 = r.rt1 = r.tot1 = (r.r - r.l + 1);
            l.lt2 = l.rt2 = l.tot2 = 0;
            r.lt2 = r.rt2 = r.tot2 = 0;
        }
        u.change = -1;
    } else if (u.yihuo == 1) {
        l.yihuo ^= u.yihuo;
        r.yihuo ^= u.yihuo;
        if (l.yihuo) {
            l.sum = (l.r - l.l + 1) - l.sum;
            swap(l.tot1, l.tot2);
            swap(l.lt1, l.lt2);
            swap(l.rt1, l.rt2);
        }
        if (r.yihuo) {
            r.sum = (r.r - r.l + 1) - r.sum;
            swap(r.tot1, r.tot2);
            swap(r.lt1, r.lt2);
            swap(r.rt1, r.rt2);
        }
        u.yihuo = 0;
    }
}

void modify_change(int u, int l, int r, int x) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].sum = (tr[u].r - tr[u].l + 1) * x;
        tr[u].change = x, tr[u].yihuo = 0;
        if (!x) {
            tr[u].lt2 = tr[u].rt2 = tr[u].tot2 = (tr[u].r - tr[u].l + 1);
            tr[u].lt1 = tr[u].rt1 = tr[u].tot1 = 0;
        } else {
            tr[u].lt1 = tr[u].rt1 = tr[u].tot1 = (tr[u].r - tr[u].l + 1);
            tr[u].lt2 = tr[u].rt2 = tr[u].tot2 = 0;
        }
    } else {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) / 2;
        if (mid >= l) {
            modify_change(u * 2, l, r, x);
        }
        if (mid < r) {
            modify_change(u * 2 + 1, l, r, x);
        }
        pushup(u);
    }
}

void modify_xor(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].yihuo ^= 1;
        if (tr[u].yihuo == 1) {
            tr[u].sum = (tr[u].r - tr[u].l + 1) - tr[u].sum;
            swap(tr[u].tot1, tr[u].tot2);
            swap(tr[u].lt1, tr[u].lt2);
            swap(tr[u].rt1, tr[u].rt2);
        }
    } else {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) / 2;
        if (mid >= l) {
            modify_xor(u * 2, l, r);
        }
        if (mid < r) {
            modify_xor(u * 2 + 1, l, r);
        }
        pushup(u);
    }
}

node query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) {
        return tr[u];
    } else {
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) / 2;
        if (mid >= r) {
            return query(u * 2, l, r);
        } else if (mid < l) {
            return query(u * 2 + 1, l, r);
        } else {
            node res1 = query(u * 2, l, r);
            node res2 = query(u * 2 + 1, l, r);
            node ans;
            pushup(ans, res1, res2);
            return ans;
        }
    }
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    build(1, 1, n);
    while (m--) {
        int op, l, r;
        cin >> op >> l >> r;
        l++, r++;
        if (!op) {
            modify_change(1, l, r, 0);
        } else if (op == 1) {
            modify_change(1, l, r, 1);
        } else if (op == 2) {
            modify_xor(1, l, r);
        } else if (op == 3) {
            cout << query(1, l, r).sum << "\n";
        } else {
            cout << query(1, l, r).tot1 << "\n";
        }
    }
    return 0;
}

具体提交记录见此