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

using ll = uint64_t;
#define rep(i, n) for(ll i = 0; i < (n); ++i)
#define rep2(i, l, r) for(ll i = (l); i < (r); ++i)

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;

#define all(A) A.begin(), A.end()
#define elif else if
using pii = pair<ll, ll>;

bool chmin(auto &a, auto b) {return a > b ? a = b, 1 : 0;}
bool chmax(auto &a, auto b) {return a < b ? a = b, 1 : 0;}

struct IOS {
  IOS() {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
} iosetup;


template<class T>
void print(vector<T> a) {
  for(auto x : a) cout << x << ' ';
  cout << endl;
}

void print(auto x) {
  cout << x << endl;
}

template<class Head, class... Tail>
void print(Head &&head, Tail &&...tail) {
  cout << head << ' ';
  print(forward<Tail>(tail)...);
}

template<class S, S (*op)(S, S), S (*e)(), 
  class F, S (*mp)(F, S), F (*cmpo)(F, F), F (*id)()>
struct lazysegtree {
  int N, sz, log;
  vector<S> d;
  vector<F> lz;

  lazysegtree() = default;
  lazysegtree(int n) : lazysegtree(vector<S>(n, e())) {};
  lazysegtree(vector<S> v) {
    N = v.size();
    sz = 1, log = 0;
    while(sz < N) sz *= 2, log++;
    d.assign(2*sz, e());
    lz.assign(2*sz, id());
    rep(i, N) d[i+sz] = v[i];
    for(int i = sz - 1; i > 0; --i) d[i] = op(d[2*i], d[2*i+1]);
  }

  void update(int k) {d[k] = op(d[2*k], d[2*k+1]);}
  void all_apply(int k, F f) {
    d[k] = mp(f, d[k]);
    if(k < sz) lz[k] = cmpo(f, lz[k]);
  }
  void push(int k) {
    all_apply(2*k, lz[k]);
    all_apply(2*k+1, lz[k]);
    lz[k] = id();
  }
  void PUSH(int k) {
    for(int i = log; i > 0; --i) push(k >> i);
  }

  bool shift(int x, int i) {return ((x >> i) << i) != x;}

  S prod(int l, int r) {
    if(l == r) return e();
    l += sz, r += sz;
    for(int i = log; i > 0; i--) {
      if(shift(l, i)) push(l >> i);
      if(shift(r, i)) push((r-1) >> i);
    }
    S sml = e(), smr = e();
    while(l < r) {
      if(l & 1) sml = op(sml, d[l++]);
      if(r & 1) smr = op(d[--r], smr);
      l >>= 1, r >>= 1;
    }
    return op(sml, smr);
  }

  void apply(int l, int r, F f) {
    if(l == r) return;
    l += sz, r += sz;
    for(int i = log; i > 0; --i) {
      if(shift(l, i)) push(l >> i);
      if(shift(r, i)) push((r-1)>>i);
    }
    int ml = l, mr = r;
    while(l < r) {
      if(l & 1) all_apply(l++, f);
      if(r & 1) all_apply(--r, f);
      l >>= 1, r >>= 1;
    }
    l = ml, r = mr;
    rep2(i, 1, log+1) {
      if(shift(l, i)) update(l >> i);
      if(shift(r, i)) update((r-1)>>i);
    }
  }

  void set(int p, S x) {
    p += sz;
    PUSH(p);
    d[p] = x;
    rep2(i, 1, log+1) update(p >> i);
  }
  S get(int p) {
    p += sz;
    PUSH(p);
    return d[p];
  }
  void apply(int p, F f) {
    p += sz;
    PUSH(p);
    d[p] = mp(f, d[p]);
    rep2(i, 1, log+1) update(p >> i);
  }
  S all_prod() {return d[1];}

  int max_right(int l, ll top) {
    if(l == N) return N;
    l += sz;
    PUSH(l);
    S sm = e();
    do {
      while(~l & l) l >>= 1;
      if(((op(sm, d[l])[0])&top)==0) {
        while(l < sz) {
          push(l);
          l <<= 1;
          if(((op(sm, d[l])[0])&top)!=0) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - sz;
      }
      sm = op(sm, d[l]);
      l++;
    } while((l & -l) != l);
    return N;
  }

};

using S=array<ll,3>;
S op(S L,S R){
  return {L[0]&R[0],(L[0]&R[1])^(R[0]&L[1]),L[2]+R[2]};
}

ll mask=9223372036854775807LL; // (1<<63)-1
S e(){
  return {mask,0,0};
}

S mapping(ll f,S x){
  if(x[2]==0)return x;
  if(x[2]==1){
    ll t=x[0]&f;
    return {t,mask^t,1};
  }
  else{
    return {x[0]&f,x[1]&f,x[2]};
  }
}

ll cmp(ll f,ll g){return f&g;}
ll ID(){return mask;}


int main(){
  int n,q;
  cin>>n>>q;
  vll a(n);
  rep(i,n)cin>>a[i];
  vector<S>init(n);
  rep(i,n){
    init[i]={a[i],a[i]^mask,1};
  }
  string ans_str;
  lazysegtree<S,op,e,ll,mapping,cmp,ID>seg(init);
  while(q--){
    int t;
    cin>>t;
    if(t==1){
      int l,r;
      ll x;
      cin>>l>>r>>x;
      seg.apply(l-1,r,x);
    }
    if(t==2){
      int s;
      ll x;
      cin>>s>>x;
      seg.set(s-1,{x,x^mask,1});
      a[s-1]=x;
    }
    if(t==3){
      int l,r;
      cin>>l>>r;
      l--;
      S val=seg.prod(l,r);
      if(val[1]==0){
        cout<<val[0]<<'\n';
      }
      else{
        ll top=__bit_floor(val[1]);
        // assert(top!=-1);
        int mid=seg.max_right(l,top);
        ll ans=seg.prod(l,mid)[0]&seg.prod(mid+1,r)[0];
        ans_str+=to_string(ans)+"\n";
      }
    }
  }
  cout<<ans_str;
}