#include<bits/stdc++.h>
using namespace std;
const int N=1e5+15;
struct tree{
	int l,r;
	bool f0,f1,f;
	int l1,r1,n1;
	int l0,r0,n0;
	int sum;
}a[N*4];
int ls(int u)
{
	return u<<1;
}
int rs(int u)
{
	return u<<1|1;
}
int fmid(int x,int y)
{
	return x+y>>1;
 } 
void pushup(int u)
{
	a[u].sum=a[ls(u)].sum+a[rs(u)].sum; 
	a[u].l1=a[ls(u)].l1;
	a[u].l0=a[ls(u)].l0;
	a[u].r1=a[rs(u)].r1;
	a[u].r0=a[rs(u)].r0;
	if(a[ls(u)].sum==(a[ls(u)].r-a[ls(u)].l+1))
	{
		a[u].l1+=a[rs(u)].l1;
	}
	else if(a[ls(u)].sum==0)
	{
		a[u].l0+=a[rs(u)].l0;
	}
	if(a[rs(u)].sum==a[rs(u)].r-a[rs(u)].l+1)
	{
		a[u].r1+=a[ls(u)].r1;
	}
	else if(a[rs(u)].sum==0)
	{
		a[u].r0+=a[ls(u)].r0;
	}
	a[u].n1=a[ls(u)].r1+a[rs(u)].l1;
	a[u].n1=max(a[u].n1,a[ls(u)].n1);
	a[u].n1=max(a[u].n1,a[rs(u)].n1);
	a[u].n0=a[ls(u)].r0+a[rs(u)].l0;
	a[u].n0=max(a[u].n0,a[ls(u)].n0);
	a[u].n0=max(a[u].n0,a[rs(u)].n0);
}
void pushdown(int u)
{
	if(a[u].f0)
	{
		a[u].f=0;
		
		a[ls(u)].n0
		=a[ls(u)].r0
		=a[ls(u)].l0
		=a[ls(u)].r-a[ls(u)].l+1;
		
		a[rs(u)].n0
		=a[rs(u)].r0
		=a[rs(u)].l0
		=a[rs(u)].r-a[rs(u)].l+1;
		
		a[ls(u)].n1
		=a[ls(u)].r1
		=a[ls(u)].l1
		=0;
		
		a[rs(u)].n1
		=a[rs(u)].r1
		=a[rs(u)].l1
		=0;
		
		a[ls(u)].f0=a[rs(u)].f0=1;
		a[ls(u)].sum=a[rs(u)].sum=0;
		a[u].f0=0;
	}
	else
	if(a[u].f1)
	{
		a[u].f=0;
		
		a[ls(u)].n0
		=a[ls(u)].r0
		=a[ls(u)].l0
		=0;
		
		a[rs(u)].n0
		=a[rs(u)].r0
		=a[rs(u)].l0
		=0;
		
		a[ls(u)].n1
		=a[ls(u)].r1
		=a[ls(u)].l1
		=a[ls(u)].r-a[ls(u)].l+1;
		
		a[rs(u)].n1
		=a[rs(u)].r1
		=a[rs(u)].l1
		=a[rs(u)].r-a[rs(u)].l+1;
		
		a[ls(u)].f1=a[rs(u)].f1=1;
		a[ls(u)].sum=a[ls(u)].r-a[ls(u)].l+1;
		a[rs(u)].sum=a[rs(u)].r-a[rs(u)].l+1;
		a[u].f1=0;
	}
	else
	if(a[u].f)
	{ 
		a[ls(u)].sum=a[ls(u)].r-a[ls(u)].l+1-a[ls(u)].sum;
		a[rs(u)].sum=a[rs(u)].r-a[rs(u)].l+1-a[rs(u)].sum;
		if(a[ls(u)].f1==1||a[ls(u)].f0==1)
		{
			a[ls(u)].f1=a[ls(u)].f1^1;
			a[ls(u)].f0=a[ls(u)].f0^1;
		}
		else
		a[ls(u)].f=a[ls(u)].f^1;
		
		if(a[rs(u)].f1==1||a[rs(u)].f0==1)
		{
			a[rs(u)].f1=a[rs(u)].f1^1;
			a[rs(u)].f0=a[rs(u)].f0^1;
		}
		else
		a[rs(u)].f=a[rs(u)].f^1;
		
		swap(a[ls(u)].l1,a[ls(u)].l0);
		swap(a[ls(u)].r1,a[ls(u)].r0);
		swap(a[ls(u)].n1,a[ls(u)].n0);
		swap(a[rs(u)].l1,a[rs(u)].l0);
		swap(a[rs(u)].r1,a[rs(u)].r0);
		swap(a[rs(u)].n1,a[rs(u)].n0);
		a[u].f=0;
	}
}
void build(int u,int l,int r)
{
	a[u].l=l;
	a[u].r=r;
	a[u].f=a[u].f1=a[u].f0=0; 
	if(l==r)
	{
		scanf("%d",&a[u].sum);
		if(a[u].sum==0)
		a[u].n0=a[u].l0=a[u].r0=1;
		else
		a[u].n1=a[u].l1=a[u].r1=1;
		return ; 
	}
	int mid=fmid(l,r);
	build(ls(u),l,mid);
	build(rs(u),mid+1,r);
	pushup(u);
}
void chance(int u,int l,int r,int x)
{
	pushdown(u);
	if(a[u].l>=l&&a[u].r<=r)
	{
		if(x==0)
		{
			a[u].f1=0;
			a[u].sum=0;
			a[u].n0=a[u].r0=a[u].l0=a[u].r-a[u].l+1;
			a[u].n1=a[u].l1=a[u].r1=0;
			a[u].f0=1;
		}
		if(x==1)
		{
			a[u].f0=0;
			a[u].sum=a[u].r-a[u].l+1;
			a[u].n1=a[u].r1=a[u].l1=a[u].r-a[u].l+1;
			a[u].n0=a[u].l0=a[u].r0=0;
			a[u].f1=1;
		}
		if(x==2)
		{
			a[u].sum=a[u].r-a[u].l+1-a[u].sum;
			swap(a[u].l1,a[u].l0);
			swap(a[u].r1,a[u].r0);
			swap(a[u].n1,a[u].n0);
			a[u].f=a[u].f^1;
		}
		return ;	
    }
		int mid=fmid(a[u].l,a[u].r);
		if(l<=mid)
		chance(ls(u),l,r,x);
		if(r>mid)
		chance(rs(u),l,r,x);
		pushup(u);
}
int ask1(int u,int l,int r)
{
	if(a[u].l>=l&&a[u].r<=r)
	{
		return a[u].sum;
	}
	pushdown(u);
	int mid=fmid(a[u].l,a[u].r),ans=0;
	if(l<=mid)
	{
		ans+=ask1(ls(u),l,r);
	}
	if(r>mid)
	{
		ans+=ask1(rs(u),l,r);
	}
	return ans;
}
tree ask2(int u,int l,int r)
{
	if(a[u].l>=l&&a[u].r<=r)
	{
		return a[u];
	}
	pushdown(u);
	int mid=fmid(a[u].l,a[u].r);
	if(r<=mid)
	return ask2(ls(u),l,r);
	if(l>mid)
	return ask2(rs(u),l,r);
		tree x=ask2(ls(u),l,r),y=ask2(rs(u),l,r),nw;
		nw.sum=x.sum+y.sum; 
		nw.l1=x.l1;
		nw.l0=x.l0;
		nw.r1=y.r1;
		nw.r0=y.r0;
		if(x.sum==(x.r-x.l+1))
		{
			nw.l1+=y.l1;
		}
		else if(x.sum==0)
		{
			nw.l0+=y.l0;
		}
		if(y.sum==y.r-y.l+1)
		{
			nw.r1+=x.r1;
		}
		else if(y.sum==0)
		{
			nw.r0+=x.r0;
		}
		nw.n1=x.r1+y.l1;
		nw.n1=max(nw.n1,x.n1);
		nw.n1=max(nw.n1,y.n1);
		nw.n0=x.r0+y.l0;
		nw.n0=max(nw.n0,x.n0);
		nw.n0=max(nw.n0,y.n0);
        return nw;
}
int n,m; 
int main()
{
	scanf("%d%d",&n,&m);
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		l++,r++;
		if(op==0||op==1||op==2)
		{
			chance(1,l,r,op);
		}
		if(op==3)
		{
			printf("%d\n",ask1(1,l,r));
		}
		if(op==4)
		{
			tree ans=ask2(1,l,r);
			printf("%d\n",ans.n1);
		}
	}
	return 0;
  }