#include <iostream>
#include <algorithm>
using namespace std;

#define lc p << 1
#define rc p << 1 | 1

const int MAXN = 1e5 + 5;
struct Node{
    int l, r;
    int sum;
    int la0, ra0, ans0;
    int la1, ra1, ans1;
    int cov;
    int rev;
}t[MAXN * 4];

int a[MAXN];
int n, m;

void setc(int p, int c){
    int len = t[p].r - t[p].l + 1;
    t[p].cov = c;
    t[p].rev = 0;
    if(c == 1){
        t[p].sum = len;
        t[p].la1 = len; t[p].ra1 = len; t[p].ans1 = len;
        t[p].la0 = 0; t[p].ra0 = 0; t[p].ans0 = 0;
    }
	else{
        t[p].sum = 0;
        t[p].la1 = 0; t[p].ra1 = 0; t[p].ans1 = 0;
        t[p].la0 = len; t[p].ra0 = len; t[p].ans0 = len;
    }
}

void neg(int p) {
    t[p].sum = (t[p].r - t[p].l + 1) - t[p].sum;
    swap(t[p].la0, t[p].la1);
    swap(t[p].ra0, t[p].ra1);
    swap(t[p].ans0, t[p].ans1);
}

void pushup(int p) {
    Node &L = t[lc];
    Node &R = t[rc];
    int lenL = L.r - L.l + 1;
    int lenR = R.r - R.l + 1;
    t[p].sum = L.sum + R.sum;
    t[p].la1 = L.la1;
    if (L.la1 == lenL) t[p].la1 = lenL + R.la1;
    t[p].ra1 = R.ra1;
    if (R.ra1 == lenR) t[p].ra1 = lenR + L.ra1;
    t[p].ans1 = max(max(L.ans1, R.ans1), L.ra1 + R.la1);
    t[p].la0 = L.la0;
    if (L.la0 == lenL) t[p].la0 = lenL + R.la0;
    t[p].ra0 = R.ra0;
    if (R.ra0 == lenR) t[p].ra0 = lenR + L.ra0;
    t[p].ans0 = max(max(L.ans0, R.ans0), L.ra0 + R.la0);
}

void pushdown(int p){
    if(t[p].cov != -1){
        setc(lc, t[p].cov);
        setc(rc, t[p].cov);
        t[p].cov = -1;
    }
    if(t[p].rev) {
        if(t[lc].cov != -1){
            t[lc].cov ^= 1;
            setc(lc, t[lc].cov);
        }
		else {
            t[lc].rev ^= 1;
            neg(lc);
        }
        if(t[rc].cov != -1){
            t[rc].cov ^= 1;
            setc(rc, t[rc].cov);
        }
		else {
            t[rc].rev ^= 1;
            neg(rc);
        }
        t[p].rev = 0;
    }
}

void build(int p, int l, int r){
    t[p].l = l; t[p].r = r;
    t[p].cov = -1; t[p].rev = 0;
    if(l == r){
        t[p].sum = a[l];
        if(a[l] == 1) {
            t[p].la1 = 1; t[p].ra1 = 1; t[p].ans1 = 1;
            t[p].la0 = 0; t[p].ra0 = 0; t[p].ans0 = 0;
        }
		else {
            t[p].la1 = 0; t[p].ra1 = 0; t[p].ans1 = 0;
            t[p].la0 = 1; t[p].ra0 = 1; t[p].ans0 = 1;
        }
        return;
    }
    int mid = (l + r) >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
    pushup(p);
}

void apply_set(int p, int l, int r, int c){
    if(l <= t[p].l && t[p].r <= r){
        setc(p, c);
        return;
    }
    pushdown(p);
    int mid = (t[p].l + t[p].r) >> 1;
    if (l <= mid) apply_set(lc, l, r, c);
    if (r > mid) apply_set(rc, l, r, c);
    pushup(p);
}

void apply_neg(int p, int l, int r){
    if(l <= t[p].l && t[p].r <= r){
        if(t[p].cov != -1){
            t[p].cov ^= 1;
            setc(p, t[p].cov);
        }
		else{
            t[p].rev ^= 1;
            neg(p);
        }
        return;
    }
    pushdown(p);
    int mid = (t[p].l + t[p].r) >> 1;
    if (l <= mid) apply_neg(lc, l, r);
    if (r > mid) apply_neg(rc, l, r);
    pushup(p);
}

int query_sum(int p, int l, int r){
    if(l <= t[p].l && t[p].r <= r) return t[p].sum;
    pushdown(p);
    int mid = (t[p].l + t[p].r) >> 1;
    int res = 0;
    if(l <= mid) res += query_sum(lc, l, r);
    if(r > mid) res += query_sum(rc, l, r);
    return res;
}

struct Res{
    int la1, ra1, ans1, len;
};

Res merge_res(Res L, Res R){
    Res res;
    res.len = L.len + R.len;
    res.la1 = L.la1;
    if(L.la1 == L.len) res.la1 = L.len + R.la1;
    res.ra1 = R.ra1;
    if(R.ra1 == R.len) res.ra1 = R.len + L.ra1;
    res.ans1 = max(max(L.ans1, R.ans1), L.ra1 + R.la1);
    return res;
}

Res query_res(int p, int l, int r){
    if(l <= t[p].l && t[p].r <= r) return { t[p].la1, t[p].ra1, t[p].ans1, t[p].r - t[p].l + 1 };
    pushdown(p);
    int mid = (t[p].l + t[p].r) >> 1;
    if(r <= mid) return query_res(lc, l, r);
	else if (l > mid) return query_res(rc, l, r);
	else{
        Res L = query_res(lc, l, r);
        Res R = query_res(rc, l, r);
        return merge_res(L, R);
    }
}

int main(){
	 freopen("sequence.in","r",stdin);
	 freopen("sequence.out","w",stdout);
    cin.tie(0) -> sync_with_stdio(0);
    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 == 0) apply_set(1, l, r, 0);
		else if(op == 1)  apply_set(1, l, r, 1);
		else if(op == 2)  apply_neg(1, l, r);
        else if(op == 3)  cout << query_sum(1, l, r) << '\n';
        else if(op == 4){
            Res res = query_res(1, l, r);
            cout << res.ans1 << '\n';
        }
    }
    return 0;
}