#pragma GCC optimize("Ofast")
#pragma GCC target("avx2,abm,mmx")
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = numeric_limits<int>::max();

struct node {
    int min, second_min, min_count, xor_sum, bits[32];
};

int n, q;
vector<int> a;
vector<node> S;

inline node combine(node l, node r) {
    node res;
    int v[] = {l.min, l.second_min, r.min, r.second_min};
    sort(v, v + 4), unique(v, v + 4), res.min = v[0], res.second_min = v[1],
                                      res.min_count = (v[0] == l.min) * l.min_count + (v[0] == r.min) * r.min_count,
                                      res.xor_sum = l.xor_sum ^ r.xor_sum;

    for (int k = 0; k < 32; ++k)
        res.bits[k] = l.bits[k] + r.bits[k];

    return res;
}

void build(int i = 1, int l = 1, int r = n) {
    if (l == r) {
        S[i].min = a[l - 1], S[i].second_min = INF, S[i].min_count = 1, S[i].xor_sum = a[l - 1];

        for (int k = 0; k < 32; ++k)
            S[i].bits[k] = (a[l - 1] >> k) & 1;

        return;
    }

    int m = l + (r - l) / 2, li = i * 2, ri = i * 2 + 1;
    build(li, l, m), build(ri, m + 1, r), S[i] = combine(S[li], S[ri]);
}

inline void tag(int i, int x) {
    if (x <= S[i].min)
        return;

    S[i].xor_sum ^= S[i].min * (S[i].min_count & 1);

    for (int k = 0; k < 32; ++k)
        S[i].bits[k] -= ((S[i].min >> k) & 1) * S[i].min_count;

    S[i].min = x;
    S[i].xor_sum ^= S[i].min * (S[i].min_count & 1);

    for (int k = 0; k < 32; ++k)
        S[i].bits[k] += ((S[i].min >> k) & 1) * S[i].min_count;
}

inline void pd(int i, int l, int r) {
    tag(l, S[i].min), tag(r, S[i].min);
}

void chmax(int ql, int qr, int x, int i = 1, int l = 1, int r = n) {
    if (qr < l || r < ql || x <= S[i].min)
        return;

    if (ql <= l && r <= qr && x < S[i].second_min) {
        tag(i, x);
        return;
    }

    int m = l + (r - l) / 2, li = i * 2, ri = i * 2 + 1;
    pd(i, li, ri), chmax(ql, qr, x, li, l, m), chmax(ql, qr, x, ri, m + 1, r);
    S[i] = combine(S[li], S[ri]);
}

node query(int ql, int qr, int i = 1, int l = 1, int r = n) {
    if (qr < l || r < ql)
        return node{};

    if (ql <= l && r <= qr)
        return S[i];

    int m = l + (r - l) / 2, li = i * 2, ri = i * 2 + 1;
    pd(i, li, ri);
    return combine(query(ql, qr, li, l, m), query(ql, qr, ri, m + 1, r));
}

int main() {
    ios_base::sync_with_stdio(0), cin.tie(0);
    cin >> n >> q;
    a.resize(n);

    for (auto &o : a)
        cin >> o;

    S.resize(n * 4), build();

    while (q--) {
        int op, l, r, x;
        cin >> op >> l >> r >> x;

        if (op == 1) {
            chmax(l, r, x);
        } else {
            node res = query(l, r);
            res.xor_sum ^= x;

            if (res.xor_sum == 0) {
                cout << "0\n";
                continue;
            }

            for (int k = 0; k < 32; ++k)
                res.bits[k] += (x >> k) & 1;


            int hb = 31 - __builtin_clz(res.xor_sum);
            cout << res.bits[hb] << '\n';
        }
    }
}