#include<cstdio>

#include<iostream>

#include<algorithm>

using namespace std;

#define N 100001

struct node

{

    int siz;

    int L[],R[],con[];

    int sum[];

    bool rev;

    int cover;

}tr[N<<];

struct node_

{

    int L1,R1,con1;

    int siz;

};

node_ operator + (node_ l,node_ r)

{

    node_ res;

    res.L1=l.L1;

    if(l.L1==l.siz) res.L1+=r.L1;

    res.R1=r.R1;

    if(r.R1==r.siz) res.R1+=l.R1;

    res.con1=max(l.con1,r.con1);

    res.con1=max(res.con1,l.R1+r.L1);

    return res;

}

int x;

int ans;

void read(int &x)

{

    x=; char c=getchar();

    while(!isdigit(c)) c=getchar();

    while(isdigit(c)) { x=x*+c-''; c=getchar(); }

}

void update(int k)

{

    for(int i=;i<=;++i)

    {

        tr[k].L[i]=tr[k<<].L[i];

        if(tr[k<<].L[i]==tr[k<<].siz) tr[k].L[i]+=tr[k<<|].L[i];

        tr[k].R[i]=tr[k<<|].R[i];

        if(tr[k<<|].R[i]==tr[k<<|].siz) tr[k].R[i]+=tr[k<<].R[i];

        tr[k].con[i]=max(tr[k<<].con[i],tr[k<<|].con[i]);

        tr[k].con[i]=max(tr[k].con[i],tr[k<<].R[i]+tr[k<<|].L[i]);

        tr[k].sum[i]=tr[k<<].sum[i]+tr[k<<|].sum[i];

    }

}

void build(int k,int l,int r)

{

    tr[k].cover=-;

    tr[k].siz=r-l+;

    if(l==r)

    {

        read(x);

        tr[k].L[x]++;

        tr[k].R[x]++;

        tr[k].con[x]++;

        tr[k].sum[x]++;

        return;

    }

    int mid=l+r>>;

    build(k<<,l,mid);

    build(k<<|,mid+,r);

    update(k);

}

void reverse(int k)

{

    swap(tr[k].L[],tr[k].L[]);

    swap(tr[k].R[],tr[k].R[]);

    swap(tr[k].con[],tr[k].con[]);

    swap(tr[k].sum[],tr[k].sum[]);

    tr[k].rev^=;

    if(tr[k].cover!=-) tr[k].cover^=;

}

void down_rev(int k)

{

    reverse(k<<);

    reverse(k<<|);

    tr[k].rev^=;

}

void covering(int k,int w)

{

    tr[k].L[w]=tr[k].R[w]=tr[k].con[w]=tr[k].sum[w]=tr[k].siz;

    tr[k].L[w^]=tr[k].R[w^]=tr[k].con[w^]=tr[k].sum[w^]=;

    tr[k].cover=w;

    tr[k].rev=false;

}

void down_cov(int k)

{

    covering(k<<,tr[k].cover);

    covering(k<<|,tr[k].cover);

    tr[k].cover=-;

}

void Cover(int k,int l,int r,int opl,int opr,int w)

{

    if(l>=opl && r<=opr)

    {

        covering(k,w);

        return;

    }

    if(tr[k].rev) down_rev(k);

    if(tr[k].cover!=-) down_cov(k);

    int mid=l+r>>;

    if(opl<=mid) Cover(k<<,l,mid,opl,opr,w);

    if(opr>mid) Cover(k<<|,mid+,r,opl,opr,w);

    update(k);

}

void Reverse(int k,int l,int r,int opl,int opr)

{

    if(l>=opl && r<=opr)

    {

        reverse(k);

        return;

    }

    if(tr[k].rev) down_rev(k);

    if(tr[k].cover!=-) down_cov(k);

    int mid=l+r>>;

    if(opl<=mid) Reverse(k<<,l,mid,opl,opr);

    if(opr>mid) Reverse(k<<|,mid+,r,opl,opr);

    update(k);

}

void query(int k,int l,int r,int opl,int opr)

{

    if(l>=opl && r<=opr)

    {

        ans+=tr[k].sum[];

        return;

    }

    if(tr[k].rev) down_rev(k);

    if(tr[k].cover!=-) down_cov(k);

    int mid=l+r>>;

    if(opl<=mid) query(k<<,l,mid,opl,opr);

    if(opr>mid) query(k<<|,mid+,r,opl,opr);

}

node_ Query(int k,int l,int r,int opl,int opr)

{

    if(l>=opl && r<=opr)

    {

        node_ res;

        res.L1=tr[k].L[];

        res.R1=tr[k].R[];

        res.con1=tr[k].con[];

        res.siz=tr[k].siz;

        return res;

    }

    if(tr[k].rev) down_rev(k);

    if(tr[k].cover!=-) down_cov(k);

    int mid=l+r>>;

    if(opr<=mid) return Query(k<<,l,mid,opl,opr);

    if(opl>mid) return Query(k<<|,mid+,r,opl,opr);

    return Query(k<<,l,mid,opl,opr)+Query(k<<|,mid+,r,opl,opr);

}

int main()

{

    int n,m;

    read(n); read(m);

    build(,,n);

    int ty,l,r;

    while(m--)

    {

        read(ty); read(l); read(r);

        l++; r++;

        switch(ty)

        {

            case  : Cover(,,n,l,r,); break;

            case  : Cover(,,n,l,r,); break;

            case  : Reverse(,,n,l,r); break;

            case  : ans=; query(,,n,l,r); cout<<ans<<'\n'; break;

            case  : printf("%d\n",Query(,,n,l,r).con1); break;

        }

    }

}