#include <bits/stdc++.h>
#include <climits>
using namespace std;
using i64 = unsigned long long;
const int INF = 0x3f3f3f3f;
const i64 mod = 1e9 + 7;
const int N = 200005;
const i64 mask = (1ULL<<63)-1ULL;
//线段树维护区间与
//同时需要维护区间那些为只出现了一次为0
//然后删除这个数
i64 a[N];
struct SegementTree {
    #define lson ((cur<<1))
    #define rson ((cur<<1)|1)
    #define mid ((l+r)>>1)

    vector<i64> d, f;
    vector<i64> lazy;

    void pushup(int cur) {
        d[cur] = d[lson]&d[rson];

        f[cur] = ((f[lson]&d[rson]) | (f[rson]&d[lson]));
    }
    void pushdown(int cur, int l, int r) {
        d[lson] &= lazy[cur];
        d[rson] &= lazy[cur];

        if(l != mid)  {
            f[lson] &= lazy[cur];
        }

        if(mid+1 != r) {
            f[rson] &= lazy[cur];
        }

        lazy[lson] &= lazy[cur];
        lazy[rson] &= lazy[cur]; 
        lazy[cur] = mask;
    }
    void update(int cur, int l, int r, int L, int R, i64 v) {
        if(L <= l and r <= R) {
            d[cur] &= v;
            if(l != r) {
                f[cur] &= v;
            }
            lazy[cur] &= v;
            return;
        }
        if(lazy[cur] != mask) {
            pushdown(cur, l, r);
        }

        if(L <= mid) {
            update(lson, l, mid, L, R, v);
        }
        if(R > mid) {
            update(rson, mid+1, r, L, R, v);
        }
        pushup(cur);
    }
    void update(int cur, int l, int r, int pos, i64 v) {
        if(l == r) {
            d[cur] = v;
            f[cur] = mask;
            return;
        }
        if(lazy[cur] != mask) {
            pushdown(cur, l, r);
        }

        if(pos <= mid) {
            update(lson, l, mid, pos, v);
        }
        else {
            update(rson, mid+1, r, pos, v);
        }
        pushup(cur);
    }

    pair<i64, i64> query(int cur, int l, int r, int L, int R) {
        if(L <= l and r <= R) {
            return  {d[cur], f[cur]};
        }
        if(lazy[cur] != mask) {
            pushdown(cur, l, r);
        }
        i64 td, tf;
        if(L <= mid and R > mid) {  
            auto r1 = query(lson, l, mid, L, R);
            auto r2 = query(rson, mid+1, r, L, R);
            td = r1.first&r2.first;
            tf = (r1.first&r2.second) | (r1.second&r2.first);
            return {td, tf}; 
        }
        else if(L <= mid) {
            return query(lson, l, mid, L, R);
        }
        else {
            return query(rson, mid+1, r, L, R);
        }
    }
    i64 find(int cur, int l, int r, int L, int R, i64 target) {
        if(lazy[cur] != mask) {
            pushdown(cur, l, r);
        }
        if(L <= l and r <= R) {
            if(f[cur]&target) {
                if(l == r) {
                    return f[cur]&target;
                }
                if((f[lson]&target) > (f[rson]&target)) {
                    return find(lson, l, mid, L, R, target);
                }
                else {
                    return find(rson, mid+1, r, L, R, target);
                }
            }
            else {
                return 0;
            }
        }
        else {
            i64 ret = 0;
            if(L <= mid) {
                ret = max(ret, find(lson, l, mid, L, R, target));
            }
            if(R > mid and !ret) {
                ret = max(ret, find(rson, mid+1, r, L, R, target));
            }
            return ret;
        }
    }
    void buildTree(int cur, int l, int r) {
        if(l == r) {
            d[cur] = a[l];
            f[cur] = mask;
            return;
        }
        buildTree(lson, l, mid);
        buildTree(rson, mid+1, r);
        pushup(cur);
    }
    SegementTree(int n) : d(n<<2, 0), f(n<<2, 0), lazy(n<<2, mask) {
        buildTree(1, 1, n);
    }
};
void solve() {
    i64 n, k;
    cin >> n >> k;
    for(int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    SegementTree T(n);
    while(k--) {
        i64 opt, l, r, x;
        cin >> opt;
        if(opt == 1) {
            cin >> l >> r >> x;
            T.update(1, 1, n, l, r, x);
        }
        else if(opt == 2) {
            cin >> l >> x;
            T.update(1, 1, n, l, x);
        }
        else {
            cin >> l >> r;
            auto [d, f] = T.query(1, 1, n, l, r);
            if(f) {
                i64 tmp = T.find(1, 1, n, l, r, f);
                d = d | (f&tmp);
            }
            cout << d << '\n';
        }

    }
};
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int t;
    t = 1;
    while(t--) {
        solve();
    }

    return 0;
}