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

int n,q;
struct node
{
	int l,r,flag1,flag2,flag3,sum,lmax0,lmax1,rmax0,rmax1,max0,max1;
}t[N*4];

void pushup(int p,int l,int r)
{
	t[p].sum=t[l].sum+t[r].sum;
	
	if(t[l].lmax0==t[l].r-t[l].l+1)
		t[p].lmax0=t[l].lmax0+t[r].lmax0;
	else
		t[p].lmax0=t[l].lmax0;
	
	if(t[l].lmax1==t[l].r-t[l].l+1)
		t[p].lmax1=t[l].lmax1+t[r].lmax1;
	else
		t[p].lmax1=t[l].lmax1;
		
	if(t[r].rmax0==t[r].r-t[r].l+1)
		t[p].rmax0=t[r].rmax0+t[l].rmax0;
	else
		t[p].rmax0=t[r].rmax0;
	
	if(t[r].rmax1==t[r].r-t[r].l+1)
		t[p].rmax1=t[r].rmax1+t[l].rmax1;
	else
		t[p].rmax1=t[r].rmax1;
	
	t[p].max0=max(t[l].max0,t[r].max0);
	t[p].max0=max(t[p].max0,t[l].rmax0+t[r].lmax0);
	
	t[p].max1=max(t[l].max1,t[r].max1);
	t[p].max1=max(t[p].max1,t[l].rmax1+t[r].lmax1);
}

void pushdown1(int p,int l,int r)
{
	if(t[p].flag1)
	{
		t[l].flag2=0;
		t[r].flag2=0;
		
		t[l].flag3=0;
		t[r].flag3=0;
		
		t[l].flag1=1-t[l].flag1;
		t[r].flag1=1-t[r].flag1;
		
		t[l].sum=t[r].sum=0;
		
		t[l].lmax0=t[l].r-t[l].l+1;
		t[r].lmax0=t[r].r-t[r].l+1;
		t[l].lmax1=t[r].lmax1=0;
	
		t[l].rmax0=t[l].r-t[l].l+1;
		t[r].rmax0=t[r].r-t[r].l+1;
		t[l].rmax1=t[r].rmax1=0;
		
		t[l].max0=t[l].r-t[l].l+1;
		t[r].max0=t[r].r-t[r].l+1;
		t[l].max1=t[r].max1=0;
		
		t[p].flag1=0;
	}
}

void pushdown2(int p,int l,int r)
{
	if(t[p].flag2)
	{
		t[l].flag1=0;
		t[r].flag1=0;
		
		t[l].flag3=0;
		t[r].flag3=0;
		
		t[l].flag2=1-t[l].flag2;
		t[r].flag2=1-t[r].flag2;
		
		t[l].sum=t[l].r-t[l].l+1;
		t[r].sum=t[r].r-t[r].l+1;
				
		t[l].lmax0=t[r].lmax0=0;
		t[l].lmax1=t[l].r-t[l].l+1;
		t[r].lmax1=t[r].r-t[r].l+1; 
	
		t[l].rmax0=t[r].rmax0=0;
		t[l].rmax1=t[l].r-t[l].l+1;
		t[r].rmax1=t[r].r-t[r].l+1;
		
		t[l].max0=t[r].max0=0;
		t[l].max1=t[l].r-t[l].l+1;
		t[r].max1=t[r].r-t[r].l+1;
		
		t[p].flag2=0;
	}
}

void pushdown3(int p,int l,int r)
{
	if(t[p].flag3)
	{
		t[l].flag3=1-t[l].flag3;
		t[r].flag3=1-t[r].flag3;
		
		t[l].sum=t[l].r-t[l].l+1-t[l].sum;
		t[r].sum=t[r].r-t[r].l+1-t[r].sum;
		
		swap(t[l].lmax0,t[l].lmax1);
		swap(t[r].lmax0,t[r].lmax1);
		
		swap(t[l].rmax0,t[l].rmax1);
		swap(t[r].rmax0,t[r].rmax1);
		
		swap(t[l].max0,t[l].max1);
		swap(t[r].max0,t[r].max1);
		
		t[p].flag3=0;
	}
}

void pushdown(int p)
{
	pushdown1(p,p*2,p*2+1);
	pushdown2(p,p*2,p*2+1);
	pushdown3(p,p*2,p*2+1);
}

void build(int p,int l,int r)
{
	t[p].l=l;
	t[p].r=r;
	
	if(l==r)
	{
		scanf("%d",&t[p].sum);
		if(t[p].sum)
			t[p].lmax1=t[p].rmax1=t[p].max1=1;	
		else
			t[p].lmax0=t[p].rmax0=t[p].max0=1;
		return;
	}
	
	int mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	
	pushup(p,p*2,p*2+1);
}

void change1(int p,int l,int r)
{
	if(t[p].l>=l && t[p].r<=r)
	{
		t[p].flag2=0;
		t[p].flag3=0;
		t[p].flag1=1-t[p].flag1;
		
		t[p].sum=0;
		
		t[p].lmax0=t[p].rmax0=t[p].max0=t[p].r-t[p].l+1;
		t[p].lmax1=t[p].rmax1=t[p].max1=0;
		
		return;
	}
	
	pushdown(p);
	
	int mid=(t[p].l+t[p].r)>>1;
	if(mid>=l)
		change1(p*2,l,r);
	if(mid<r)
		change1(p*2+1,l,r);
	
	pushup(p,p*2,p*2+1);
}

void change2(int p,int l,int r)
{
	if(t[p].l>=l && t[p].r<=r)
	{
		t[p].flag1=0;
		t[p].flag3=0;
		t[p].flag2=1-t[p].flag2;
		
		t[p].sum=t[p].r-t[p].l+1;
		
		t[p].lmax0=t[p].rmax0=t[p].max0=0;
		t[p].lmax1=t[p].rmax1=t[p].max1=t[p].r-t[p].l+1;
		
		return;
	}
	
	pushdown(p);
	
	int mid=(t[p].l+t[p].r)>>1;
	if(mid>=l)
		change2(p*2,l,r);
	if(mid<r)
		change2(p*2+1,l,r);
	
	pushup(p,p*2,p*2+1);
}

void change3(int p,int l,int r)
{
	if(t[p].l>=l && t[p].r<=r)
	{
		t[p].flag3=1-t[p].flag3;
		
		t[p].sum=t[p].r-t[p].l+1-t[p].sum;
		
		swap(t[p].lmax0,t[p].lmax1);
		swap(t[p].rmax0,t[p].rmax1);
		swap(t[p].max0,t[p].max1);
		
		return;
	}
	
	pushdown(p);
	
	int mid=(t[p].l+t[p].r)>>1;
	if(mid>=l)
		change3(p*2,l,r);
	if(mid<r)
		change3(p*2+1,l,r);
	
	pushup(p,p*2,p*2+1);
}

int query1(int p,int l,int r)
{
	if(t[p].l>=l && t[p].r<=r)
		return t[p].sum;
	
	pushdown(p);
	
	int mid=(t[p].l+t[p].r)>>1,sum=0;
	if(mid>=l)
		sum+=query1(p*2,l,r);
	if(mid<r)
		sum+=query1(p*2+1,l,r);
	
	return sum;
}

 node query2(int p,int l,int r)
 {
 	if(t[p].l>=l && t[p].r<=r)
 		return t[p];
 	
 	pushdown(p);
 	
 	int mid=(t[p].l+t[p].r)>>1;
 	if(mid>=r)
 		return query2(p*2,l,r);
 	else if(mid<l)
 		return query2(p*2+1,l,r);
 	
 	else
 	{
 		node ans1=query2(p*2,l,r);
 		node ans2=query2(p*2+1,l,r);
 		node ans3;
 		
 		if(ans1.lmax0==ans1.r-ans1.l+1)
 			ans3.lmax0=ans1.lmax0+ans2.lmax0;
 		else
 			ans3.lmax0=ans1.lmax0;
 			
 		if(ans1.lmax1==ans1.r-ans1.l+1)
 			ans3.lmax1=ans1.lmax1+ans2.lmax1;
 		else
 			ans3.lmax1=ans1.lmax1;
 			
 		if(ans2.rmax0==ans2.r-ans2.l+1)
 			ans3.rmax0=ans2.rmax0+ans1.rmax0;
 		else
 			ans3.rmax0=ans2.rmax0;
 			
 		if(ans2.rmax1==ans2.r-ans2.l+1)
 			ans3.rmax1=ans2.rmax1+ans1.rmax1;
 		else
 			ans3.rmax1=ans2.rmax1;
 			
 		ans3.max0=max(ans1.max0,ans2.max0);
 		ans3.max0=max(ans3.max0,ans1.rmax0+ans2.lmax0);
 		
 		ans3.max1=max(ans1.max1,ans2.max1);
 		ans3.max1=max(ans3.max1,ans1.rmax1+ans2.lmax1);
 		
 		return ans3;
	}
 }

int main( void )
{
	scanf("%d%d",&n,&q);
	build(1,1,n);
	
	while(q--)
	{
		int opt,l,r;
		scanf("%d%d%d",&opt,&l,&r);
		l++;r++; 
		
		if(opt==0)
			change1(1,l,r);
		
		else if(opt==1)
			change2(1,l,r);
		
		else if(opt==2)
			change3(1,l,r);
		
		else if(opt==3)
			printf("%d\n",query1(1,l,r));
		
		else
			printf("%d\n",query2(1,l,r).max1);
	}
	
	return 0;
}