//                              -    주의 만세!

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<climits>

#define fi first
#define se second
#define mkp std::make_pair
using llu=long long unsigned;
using ll=long long;
using std::max;
using std::min;
template<class T> void cmax(T&a,T b){a=max(a,b);}
template<class T> void cmin(T&a,T b){a=min(a,b);}

namespace io{//{{{
	const int __SIZE=(1<<21)+1;
	char ibuf[__SIZE],*iS,*iT,obuf[__SIZE],*oS=obuf,*oT=oS+__SIZE-1,__c,qu[55];int __f,qr,_eof;
	#define Gc()(char)(iS==iT?(iT=(iS=ibuf)+fread(ibuf,1,__SIZE,stdin),(iS==iT?EOF:*iS++)):*iS++)
	inline void flush(){fwrite(obuf,1,oS-obuf,stdout),oS=obuf;}
	inline void gc(char&x){x=Gc();}
	inline void pc(char x){*oS++=x;if(oS==oT)flush();}
	inline void pstr(const char*s){int __len=(int)strlen(s);for(__f=0;__f<__len;++__f)pc(s[__f]);}
	inline void gstr(char*s){for(__c=Gc();__c<32||__c>126||__c==' ';)__c=Gc();
		for(;__c>31&&__c<127&&__c!=' '&&__c!='\n'&&__c!='\r';++s,__c=Gc())*s=__c;
        *s=0;}
	template<class I>inline bool gi(I&x){_eof=0;
		for(__f=1,__c=Gc();(__c<'0'||__c>'9')&&!_eof;__c=Gc()){if(__c=='-')__f=-1;_eof|=__c==EOF;}
		for(x=0;__c<='9'&&__c>='0'&&!_eof;__c=Gc())x=x*10+(__c&15),_eof|=__c==EOF;
        x*=__f;return!_eof;}
	template<class I>inline void pi(I x){if(!x)pc('0');if(x<0)pc('-'),x=-x;
		while(x)qu[++qr]=x%10+'0',x/=10;
        while(qr)pc(qu[qr--]);}
    template<class I>inline void pil(I x){pi(x);pc(10);}
    template<class I>inline void pis(I x){pi(x);pc(32);}
	struct Flusher_{~Flusher_(){flush();}}io_flusher_;
}using io::gi;using io::pi;using io::pis;using io::pil;//}}}

const int INF=INT_MAX;
ll lb[9],rb[9];
int getb(int x){
    int ans=1;
    while(x>rb[ans]) ++ans;
    return ans;
}
const int NV=5e5;
const int B=16;
int N,a[NV+5];

namespace seg{
    const int L=32;
    struct SEGN{
        ll s,taf,cn;
        int mx,mn;
    } tr[9][40005];
    void up(int b,int x){
        tr[b][x].s=tr[b][x*2].s+tr[b][x*2+1].s;
        tr[b][x].cn=tr[b][x*2].cn+tr[b][x*2+1].cn;
        tr[b][x].mx=max(tr[b][x*2].mx,tr[b][x*2+1].mx);
        tr[b][x].mn=min(tr[b][x*2].mn,tr[b][x*2+1].mn);
    }void dn(int b,int x){
        if(!tr[b][x].taf) return;
        ll taf=tr[b][x].taf;
        if(tr[b][x*2].cn){
            tr[b][x*2].taf+=taf;
            tr[b][x*2].s-=taf*tr[b][x*2].cn;
            tr[b][x*2].mx-=taf;
            tr[b][x*2].mn-=taf;
        }
        if(tr[b][x*2+1].cn){
            tr[b][x*2+1].taf+=taf;
            tr[b][x*2+1].s-=taf*tr[b][x*2+1].cn;
            tr[b][x*2+1].mx-=taf;
            tr[b][x*2+1].mn-=taf;
        }
        tr[b][x].taf=0;
    }void bfdn(int b,int l,int r,ll&z){
        if(!z) return;
        for(int i=l;i<=r;++i) if(lb[b]<=a[i]&&a[i]<=rb[b]) a[i]-=z;
        z=0;
    }void bfup(int b,int x,int l,int r){
        tr[b][x].cn=tr[b][x].s=tr[b][x].mx=0;
        tr[b][x].mn=INF;
        for(int i=l;i<=r;++i) if(lb[b]<=a[i]&&a[i]<=rb[b]){
            ++tr[b][x].cn;
            tr[b][x].s+=a[i];
            cmax(tr[b][x].mx,a[i]);
            cmin(tr[b][x].mn,a[i]);
        }
    }void ins(int b,int x,int l,int r,int p,int z){
        if(r-l+1<=L){
            bfdn(b,l,r,tr[b][x].taf);
            a[p]=z;
            bfup(b,x,l,r);
            return;
        }
        int mid=l+r>>1;
        dn(b,x);
        if(p<=mid) ins(b,x*2,l,mid,p,z);
        else ins(b,x*2+1,mid+1,r,p,z);
        up(b,x);
    }void add(int b,int x,int l,int r,int ql,int qr,int z){
        if(tr[b][x].mx<=z) return;
        if(r-l+1<=L){
            bfdn(b,l,r,tr[b][x].taf);
            for(int i=max(l,ql);i<=min(r,qr);++i) if(lb[b]<=a[i]&&a[i]<=rb[b])
                if(a[i]>z){
                    a[i]-=z;
                    if(a[i]<lb[b]) ins(getb(a[i]),1,1,N,i,a[i]);
                }
            bfup(b,x,l,r);
            return;
        }
        if(ql<=l&&r<=qr&&tr[b][x].mn-z>=lb[b]){
            tr[b][x].mn-=z;
            tr[b][x].mx-=z;
            tr[b][x].taf+=z;
            tr[b][x].s-=z*tr[b][x].cn;
            return;
        }
        int mid=l+r>>1;
        dn(b,x);
        if(ql<=mid) add(b,x*2,l,mid,ql,qr,z);
        if(mid<qr) add(b,x*2+1,mid+1,r,ql,qr,z);
        up(b,x);
    }void que(int b,int x,int l,int r,int ql,int qr,ll&sum,int&mx,int&mn){
        if(ql<=l&&r<=qr){
            sum+=tr[b][x].s;
            cmax(mx,tr[b][x].mx);
            cmin(mn,tr[b][x].mn);
            return;
        }
        if(r-l+1<=L){
            bfdn(b,l,r,tr[b][x].taf);
            for(int i=max(l,ql);i<=min(r,qr);++i) if(lb[b]<=a[i]&&a[i]<=rb[b]){
                sum+=a[i];
                cmax(mx,a[i]);
                cmin(mn,a[i]);
            }
            bfup(b,x,l,r);
            return;
        }
        int mid=l+r>>1;
        dn(b,x);
        if(ql<=mid) que(b,x*2,l,mid,ql,qr,sum,mx,mn);
        if(mid<qr) que(b,x*2+1,mid+1,r,ql,qr,sum,mx,mn);
        up(b,x);
    }
}

namespace xm{
    void _(){
        for(int i=1;i<=8;++i)
        for(int j=0;j<40005;++j) seg::tr[i][j].mn=INF;

        int Q;

        gi(N);
        gi(Q);
        for(int i=1;i<=8;++i){
            lb[i]=rb[i-1]+1;
            rb[i]=lb[i]*B-1;
        }
        for(int i=1;i<=N;++i){
            gi(a[i]);
            seg::ins(getb(a[i]),1,1,N,i,a[i]);
        }

        int lastans=0;
        while(Q--){
            int op,l,r;
            gi(op);
            gi(l);
            gi(r);
            l^=lastans;
            r^=lastans;
            if(op==1){
                int x;
                gi(x);
                x^=lastans;
                for(int i=1;i<=8;++i) if(rb[i]>=x) seg::add(i,1,1,N,l,r,x);
            }else{
                ll sum=0;
                int mx=0,mn=INF;
                for(int i=1;i<=8;++i) seg::que(i,1,1,N,l,r,sum,mx,mn);
                pis(sum);
                pis(mn);
                pil(mx);
                lastans=sum%(1<<20);
            }
        }
    }
}

int main(){
    xm::_();
    return 0;
}