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

//template
#define rep(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define ALL(v) (v).begin(),(v).end()
typedef long long int ll;
const int inf = 0x3fffffff; const ll INF = 0x1fffffffffffffff; const double eps=1e-12;
template<typename T>inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<typename T>inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
//end

template<typename M,typename N
   ,M (*f)(M,M),M (*g)(M,N),N (*h)(N,N)>
class LazySegmentTree{
   int sz,height; vector<M> data; vector<N> lazy;
   const M m1; const N n1;
   M ref(int k){return g(data[k],lazy[k]);}
   void recalc(int k){while(k>>=1)data[k]=f(ref(2*k),ref(2*k+1));}
   void thrust(int k){for(int i=height;i>0;i--)eval(k>>i);}
   void eval(int k){
      lazy[2*k]=h(lazy[2*k],lazy[k]); lazy[2*k+1]=h(lazy[2*k+1],lazy[k]);
      data[k]=ref(k); lazy[k]=n1;
   }
public:
   LazySegmentTree(int n,const M &m1,const N n1):m1(m1),n1(n1){
      sz=1,height=0; while(sz<n)sz<<=1,height++;
      data.assign(2*sz,m1); lazy.assign(2*sz,n1);
   }
   void build(vector<M> v){
      rep(i,0,v.size())data[i+sz]=v[i];
      for(int k=sz-1;k>0;k--)data[k]=f(data[2*k],data[2*k+1]);
   }
   void set(int a,M x){thrust(a+=sz); data[a]=x; recalc(a);}
   void update(int a,int b,N x){
      thrust(a+=sz); thrust(b+=sz-1);
      for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
         if(l&1)lazy[l]=h(lazy[l],x),++l;
         if(r&1)--r,lazy[r]=h(lazy[r],x);
      }
      recalc(a); recalc(b);
   }
   M query(int a,int b){
      thrust(a+=sz); thrust(b+=sz-1);
      M L=m1,R=m1;
      for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
         if(l&1)L=f(L,ref(l++));
         if(r&1)R=f(ref(--r),R);
      } return f(L,R);
   }
};

struct S{ll sum,ecnt,ocnt;};
struct T{ll state,x;};
S f(S a,S b){
   a.sum+=b.sum;
   a.ecnt+=b.ecnt;
   a.ocnt+=b.ocnt;
   return a;
}

S g(S a,T b){
   if(b.state==1)a.sum=a.ocnt;
   else if(b.state==2){
      swap(a.ocnt,a.ecnt);
      a.sum=a.ocnt;
   }
   a.sum+=b.x*(a.ecnt+a.ocnt);
   if(b.x&1)swap(a.ecnt,a.ocnt);
   return a;
}

T h(T a,T b){
   if(b.state){
      if((a.state==2) xor (a.x&1)){
         b.state^=3;
      }
      return b;
   }
   else{
      a.x+=b.x;
      return a;
   }
}

int main(){
   int n,q; cin>>n>>q;
   LazySegmentTree<S,T,f,g,h> seg(n,S{0,1,0},T{0,0});
   vector<S> a(n);
   rep(i,0,n){
      int x; cin>>x;
      a[i]=S{x,!(x&1),(x&1)};
   }
   seg.build(a);

   rep(i,0,q){
      int t; cin>>t;
      if(t==1){
         int lb,rb; cin>>lb>>rb; lb--;
         seg.update(lb,rb,T{1,0});
      }
      if(t==2){
         int lb,rb,x; cin>>lb>>rb>>x; lb--;
         seg.update(lb,rb,T{0,x});
      }
      if(t==3){
         int lb,rb; cin>>lb>>rb; lb--;
         ll res=seg.query(lb,rb).sum;
         cout<<res<<endl;
      }
   }
   return 0;
}