//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx2,abm,mmx")
#include<bits/stdc++.h>
#define ll long long
#define irep(i,l,r) for(ll i = l; i <= r; ++i)
using namespace std;
inline int read(){
	int s=0;
	char chcc=getchar();
	while(chcc<'0'||chcc>'9')chcc = getchar();
	while(chcc>='0'&&chcc<='9') s=(s<<3)+(s<<1)+(chcc^48),chcc=getchar();
	return s;
}
const int N = 1200999;
const int itinf = 2000000000;
int n, m;
struct node{
	int bsum[31];
	int xorsum, mn, smn, len, tag;
	node(){}
}t[N];

int mdcnt = 0;

void update(int x){
	
	t[x].mn = min(t[x << 1].mn, t[x << 1 | 1].mn);
	t[x].smn = itinf;
	if(t[x << 1].mn > t[x].mn)t[x].smn = min(t[x].smn, t[x << 1].mn);
	if(t[x << 1].smn > t[x].mn)t[x].smn = min(t[x].smn, t[x << 1].smn);
	if(t[x << 1 | 1].mn > t[x].mn)t[x].smn = min(t[x].smn, t[x << 1 | 1].mn);
	if(t[x << 1 | 1].smn > t[x].mn)t[x].smn = min(t[x].smn, t[x << 1 | 1].smn);
	
	t[x].len = 0, t[x].xorsum = t[x << 1].xorsum ^ t[x << 1 | 1].xorsum;
	if(t[x << 1].mn == t[x].mn)t[x].len += t[x << 1 | 1].len;
	if(t[x << 1 | 1].mn == t[x].mn)t[x].len += t[x << 1 | 1].len;
	irep(i,0,30)t[x].bsum[i] = t[x << 1].bsum[i] + t[x << 1 | 1].bsum[i];
}

void operate(int x,int lim){
	if(t[x].mn >= lim)return;
	if(t[x].len & 1)t[x].xorsum ^= (lim ^ t[x].mn);
	t[x].tag = lim;
	int od = t[x].mn, nw = lim;
	irep(i,0,30){
		t[x].bsum[i] += ((nw & 1) - (od & 1)) * t[x].len;
		nw >>= 1, od >>= 1;
	}
	t[x].mn = lim;
}

void pushdown(int x){
	int tag = t[x].tag;
	t[x].tag = 0;
	if(t[x << 1].mn < tag)operate(x << 1,tag);
	if(t[x << 1 | 1].mn < tag)operate(x << 1 | 1,tag);
}

void build(int x,int l,int r){
	if(l == r){
		int val;
		val = t[x].mn = t[x].xorsum = read();
		t[x].len = 1;
		t[x].smn = t[x].tag = itinf;
		irep(i,0,30){
			t[x].bsum[i] += val & 1;
			val >>= 1;
		}
		return;
	}
	int mid = (l + r) >> 1;
	build(x << 1,l, mid);
	build(x << 1 | 1, mid + 1, r);
	update(x);
	return;
}
void modify(int x,int l,int r,int L,int R, int lim){
	
	// x -> max(x, val)
	if(l > R || L > r)return;
	if(L <= l && r <= R){
		if(lim <= t[x].mn)return;
		if(l != r && t[x].tag)pushdown(x);
		if(lim <= t[x].smn){
			operate(x,lim);
			return;
		}
		if(t[x].tag)pushdown(x);
		int mid = (l + r) >> 1;
		if(l == r)return;
		modify(x << 1,l, mid, L,R,lim);
		modify(x << 1 | 1, mid + 1, r ,L,R,lim);
		update(x);
		return;
	}
	if(l != r && t[x].tag)pushdown(x);
	int mid = (l + r) >> 1;
	modify(x << 1,l, mid, L,R,lim);
	modify(x << 1 | 1, mid + 1, r ,L,R,lim);
	update(x);
	return;
}
int xor_query(int x,int l,int r,int L,int R){
	
	if(l > R || L > r)return 0;
	if(L <= l && r <= R)return t[x].xorsum;
	if(t[x].tag && l != r)pushdown(x);
	int mid = (l + r) >> 1;//++ mdcnt;
	return xor_query(x << 1,l,mid,L,R) ^ xor_query(x << 1 | 1,mid+1,r,L,R);
}
int bit_cnt(int x,int l, int r, int L ,int R,int id){
	if(l > R || L > r)return 0;
	if(L <= l && r <= R)return t[x].bsum[id];
	if(l != r && t[x].tag)pushdown(x);
	int mid = (l + r) >> 1;//++ mdcnt;
	return bit_cnt(x << 1 ,l,mid,L,R,id) + bit_cnt(x << 1 | 1,mid+1,r,L,R,id);
}
int main(){
	n = read(), m = read();
	build(1,1,n);
	while(m --){
		int op = read(), l = read(), r = read(), x = read();
		if(op == 1){
			modify(1,1,n,l,r,x);
		}else{
			ll key = xor_query(1,1,n,l,r);
			if((key ^ x) == 0){
				puts("0");
				continue;
			}
			int hb = log2(key ^ x);
			ll ans = bit_cnt(1,1,n,l,r,hb);
			if(x & (1 << hb))++ ans;
			printf("%lld\n",ans);
		}
	}
	return 0;
}