求调，悬赏关注

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

#define newline putchar('\n')
#define newspace putchar(' ')
#define ll long long
#define inf 1000000005
#define mod 998244353
#define eps 0.0000001
#define pii pair<int,int>
#define fi first
#define se second
#define pb push_back
#define N 500005

namespace fastIO {
    template<class T> void read(T &x) {
        x=0;
        int fl=1;
        char ch=getchar();
        while(ch<'0'||ch>'9') {
            if(ch=='-')fl=-1;
            ch=getchar();
        }
        while(ch>='0'&&ch<='9') {
            x=(x<<1)+(x<<3)+(ch&15);
            ch=getchar();
        }
        x*=fl;
    }
    template<class T> void read(T &x,T &y) {
        read(x);
        read(y);
    }
    template<class T> void read(T &x,T &y,T &z) {
        read(x);
        read(y);
        read(z);
    }
    template<class T> void write(T x) {
        if(x<0) {
            putchar('-');
            x=-x;
        }
        if(x/10)write(x/10);
        putchar(x%10+'0');
    }
    template<class T> void read(T *a,T n) {
        for(int i=1; i<=n; i++)read(a[i]);
    }
    template<class T> void write(T *a,T n) {
        for(int i=1; i<=n; i++)write(a[i]),newspace;
    }
}

using namespace fastIO;

namespace math {
    template<class T> ll fastpow(T a,T b,T md=1e18) {
        ll ans=1;
        for(; b; b>>=a,a=(a*a)%mod)if(b&1)ans=ans*a%md;
        return ans;
    }
    template<class T> ll A(T n,T m,T md=1e18) {
        ll ans1=1,ans2=1;
        for(int i=1; i<=n-m; i++)ans1=ans1*i%md,ans2=ans2*i%md;
        for(int i=n-m=1; i<=n; i++)ans1=ans1*i%md;
        return ans1*fastpow(ans2,md-2,md)%md;
    }
    template<class T> ll C(int n,int m,T md=1e18) {
        return A(n,m,md)*fastpow(A(m,m,md),md-2,md)%md;
    }
    template<class T> ll myfloor(T n,T m) {
        return n%m==0 ? n/m : (n/m+1);
    }
}

using namespace math;

int n,m;
struct tree {
    int l,r;
    int sum;
    int tag;//翻转 
    int res;
    int lval[2],rval[2];
    int val[2];
    //int len;
} t[N<<2];
int a[N];

int lson(int p) {
    return p<<1;
}
int rson(int p) {
    return (p<<1)|1;
}
int md(int l,int r) {
    return (l+r)>>1;
}
#define lp (p<<1)
#define rp ((p<<1)|1)

void pushup(int p) {
    t[p].sum = t[lp].sum + t[rp].sum;
    for (int i = 0; i < 2; i ++) {
        t[p].lval[i] = t[lp].lval[i];
        if (t[lp].lval[i] == t[lp].r - t[lp].l + 1) t[p].lval[i] += t[rp].lval[i];
        //if (i==0 && t[lp].)
        t[p].rval[i] = t[rp].rval[i];
        if (t[rp].lval[i] == t[rp].r - t[rp].l + 1) t[p].rval[i] += t[lp].rval[i];
        t[p].val[i] = max(t[lp].val[i], t[rp].val[i]);
        t[p].val[i] = max(t[p].val[i], t[lp].rval[i] + t[rp].lval[i]);
    }
}

void change(int p) {
    swap(t[p].lval[0], t[p].lval[1]);
    swap(t[p].rval[0], t[p].rval[1]);
    swap(t[p].val[0], t[p].val[1]);
}

void get(int p,int v) {
    t[p].sum = (t[p].r - t[p].l + 1) * v;
    t[p].lval[v] = t[p].rval[v] = t[p].val[v] = t[p].r - t[p].l + 1;
    t[p].lval[v^1] = t[p].rval[v^1] = t[p].val[v^1] = 0;
}

void pushdown(int p) {
    if (t[p].res != -1) {
        int v = t[p].res;
        t[p].tag = 0;
        t[lp].res = t[rp].res = v;
        t[lp].sum = (t[lp].r - t[lp].l + 1) * v;
        t[rp].sum = (t[rp].r - t[rp].l + 1) * v;
        t[lp].tag = t[rp].tag = 0;
        t[lp].lval[v] = t[lp].rval[v] = t[lp].val[v] = t[lp].r - t[lp].l + 1;
        t[rp].lval[v] = t[rp].rval[v] = t[rp].val[v] = t[rp].r - t[rp].l + 1;
        t[lp].lval[v^1] = t[lp].rval[v^1] = t[lp].val[v^1] = 0;
        t[rp].lval[v^1] = t[rp].rval[v^1] = t[rp].val[v^1] = 0;
        t[p].res = -1;
    }
    if (t[p].tag) {
        t[lp].sum = (t[lp].r - t[lp].l + 1) - t[lp].sum;
        t[rp].sum = (t[rp].r - t[rp].l + 1) - t[rp].sum;
        if (t[lp].res != -1) t[lp].res ^= 1;
        else t[lp].tag ^= 1;
        if (t[rp].res != -1) t[rp].res ^= 1;
        else t[rp].tag ^= 1;
        change(lp);
        change(rp);
        t[p].tag=0; 
    }
}

void build(int p,int l,int r) {
    t[p].l = l,t[p].r = r;
    t[p].res = -1;
    if (l == r) {
        t[p].sum = a[l];
        t[p].lval[a[l]] = 1,t[p].rval[a[l]] = 1,t[p].val[a[l]] = 1;
        return ;
    }
    int mid=md(l,r);
    build(lp, l, mid);
    build(rp, mid+1, r);
    pushup(p);
}

void update(int p,int l,int r,int op) {
    pushdown(p);
    if (l <= t[p].l && t[p].r <= r) {
        if (op == 0 || op == 1) {
            t[p].res=op;
            get(p, op);
        } else {
            t[p].sum = (t[p].r - t[p].l + 1) - t[p].sum;
            t[p].tag ^= 1;
            change(p); 
        }
        return ;
    }
    int mid = md(t[p].l , t[p].r);
    if (l<=mid) update(lp, l, r, op);
    if (mid<r) update(rp, l, r, op);
    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 ans = 0;
    int mid = md(t[p].l, t[p].r);
    if (l<=mid) ans += query_sum(lp, l, r);
    if (mid<r) ans += query_sum(rp, l, r);
    return ans;
}

int query_max(int p,int l,int r) {
    if (l <= t[p].l && t[p].r <= r) return t[p].val[1];
    pushdown(p);
    int ans = 0;
    int mid = md(t[p].l, t[p].r);
    if (l<=mid) ans = max(ans, query_max(lp, l, r));
    if (mid<r) ans = max(ans, query_max(rp, l, r));
    return ans;
}

signed main() {
    read(n, m);
    for (int i = 1; i <= n; i ++) read(a[i]);
    build(1, 1, n);
    while (m--) {
        int op,l,r;
        l++,r++;
        read(op, l, r);
        if (op <= 2) update(1, l, r, op);
        else if (op == 3) write(query_sum(1, l, r)),newline;
        else write(query_max(1, l, r)),newline;
    }
    return 0;
}