要求讓你實現支援以上要求的資料結構。

本題的特點主要是這些操作都是區間的位運算。由於這裡最多隻有20位，而且每一次的左移和右移都是強制補齊到20位的左移和右移，所以我們可以考慮線段樹維護每一位的情況。考慮線段樹的每一個節點i，它對應的sum[j]表示對應區間中有多少個數字的第j位是1。當遇到區間的 或 或者 與 操作的時候，就可以按照位去操作。

對於或操作，如果對應的位是1，那麼把這個區間的對應位改為區間長度，如果是0，那麼不發生改變。對於與操作，如果對應位是1，那麼不發生改變，如果是0，那麼對應位變為0。用上lazy標記按照普通線段樹的套路去該即可。

然後我們看這個移位操作。顯然，左移和右移在本質上一樣的，右移x位相當於左移20-x位，所以我們實現一個即可。我們實現左移操作。對於一個左移操作，相當於把每一位的位置移動一下，對應到線段樹中也是一樣，把每個sum的位置移動以下就行了。需要注意的是，由於是區間操作，所以這個移位操作同樣也要打上lazy標記，區間的lazy標記可以累加，累加的時候對於20取模。

最後，有一個坑點，就是在push_down的時候，要先把移位操作的lazy給push再處理或和與操作的lazy。具體見程式碼：

#include<bits/stdc++.h>
#define LL long long
#define mod 1000000007
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define INF 0x3f3f3f3f
#define sf(x) scanf("%d",&x)
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#define sc(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define clr(x,n) memset(x,0,sizeof(x[0])*(n+5))
#define file(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout)

using namespace __gnu_pbds;
using namespace std;

const int N = 2e5 + 10;
const int K = 20;

int a[N],tmp[K];

struct ST
{
    #define ls i<<1
    #define rs i<<1|1

    struct node
    {
        int sum[K],l,r;
        short bit;
    } T[N<<2];

    inline void shift(int i,int x)
    {
        T[i].bit=(T[i].bit+x)%K;
        for(int j=0;j<K;j++)
            tmp[j]=T[i].sum[(j-x+K)%K];
        for(int j=0;j<K;j++)
            T[i].sum[j]=tmp[j];
    }

    inline void push_up(int i)
    {
        for(int j=0;j<K;j++)
            T[i].sum[j]=T[ls].sum[j]+T[rs].sum[j];
    }

    void build(int i,int l,int r)
    {
        T[i].l=l; T[i].r=r; T[i].bit=0;
        for(int j=0;j<K;j++) T[i].sum[j]=0;
        if (l==r)
        {
            for(int j=0;j<K;j++)
                T[i].sum[j]=(a[l]>>j)&1;
            return;
        }
        int mid=(l+r)>>1;
        build(ls,l,mid);
        build(rs,mid+1,r);
        push_up(i);
    }

    inline void push_down(int i)
    {
        if (T[i].bit)
        {
            shift(ls,T[i].bit);
            shift(rs,T[i].bit);
            T[i].bit=0;
        }
        for(int j=0;j<K;j++)
        {
            if (T[i].sum[j]==T[i].r-T[i].l+1)
            {
                T[ls].sum[j]=T[ls].r-T[ls].l+1;
                T[rs].sum[j]=T[rs].r-T[rs].l+1;
            }
            if (T[i].sum[j]==0) T[ls].sum[j]=T[rs].sum[j]=0;
        }
    }

    void AND(int i,int l,int r,int x)
    {
        if (T[i].l==l&&T[i].r==r)
        {
            for(int j=0;j<K;j++)
                if (!((x>>j)&1)) T[i].sum[j]=0;
            return;
        }
        push_down(i);
        int mid=(T[i].l+T[i].r)>>1;
        if (mid>=r) AND(ls,l,r,x);
        else if (mid<l) AND(rs,l,r,x);
        else AND(ls,l,mid,x),AND(rs,mid+1,r,x);
        push_up(i);
    }

    void OR(int i,int l,int r,int x)
    {
        if (T[i].l==l&&T[i].r==r)
        {
            for(int j=0;j<K;j++)
                if (((x>>j)&1)) T[i].sum[j]=r-l+1;
            return;
        }
        push_down(i);
        int mid=(T[i].l+T[i].r)>>1;
        if (mid>=r) OR(ls,l,r,x);
        else if (mid<l) OR(rs,l,r,x);
        else OR(ls,l,mid,x),OR(rs,mid+1,r,x);
        push_up(i);
    }

    void SHIFT(int i,int l,int r,int x)
    {
        if (T[i].l==l&&T[i].r==r)
        {
            shift(i,x);
            return;
        }
        push_down(i);
        int mid=(T[i].l+T[i].r)>>1;
        if (mid>=r) SHIFT(ls,l,r,x);
        else if (mid<l) SHIFT(rs,l,r,x);
        else SHIFT(ls,l,mid,x),SHIFT(rs,mid+1,r,x);
        push_up(i);
    }

    LL getsum(int i,int l,int r)
    {
        if (T[i].l==l&&T[i].r==r)
        {
            LL res=0;
            for(int j=0;j<K;j++)
                res+=(LL)T[i].sum[j]*(1ll<<j);
            return res;
        }
        push_down(i);
        int mid=(T[i].l+T[i].r)>>1;
        if (mid>=r) return getsum(ls,l,r);
        else if (mid<l) return getsum(rs,l,r);
        else return getsum(ls,l,mid)+getsum(rs,mid+1,r);
    }
} seg;

int main()
{
    int n,q;
    sf(n); sf(q);
    for(int i=1;i<=n;i++) sf(a[i]);
    seg.build(1,1,n);
    while(q--)
    {
        int op,l,r,x;
        sc(op,l,r); sf(x);
        if (op==1)
        {
            x%=K;
            if (!x) continue;
            seg.SHIFT(1,l,r,K-x);
        } else
        if (op==2)
        {
            x%=K;
            if (!x) continue;
            seg.SHIFT(1,l,r,x);
        } else
        if (op==3) seg.OR(1,l,r,x); else
        if (op==4) seg.AND(1,l,r,x); else
        printf("%lld\n",seg.getsum(1,l,r));
    }
    return 0;
}