import java.io.*;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class TaskE_opt {
    private final InputReader reader;
    private final OutputWriter writer;

    public TaskE_opt(InputReader reader, OutputWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWriter writer = new OutputWriter(System.out);
        new TaskE_opt(reader, writer).run();
        writer.writer.flush();
    }

    class FixedPointSegmentTree {
        int[] T;
        int N;
        FixedPointSegmentTree(int n) {
            N = 1;
            while (N < n)
                N <<= 1;
            T = new int[2 * N];
        }
        void add(int l, int r, int x) {
            l += N;
            r += N;
            while (r >= l) {
                if ((l & 1) == 1)
                    T[l] ^= x;
                if ((r & 1) == 0)
                    T[r] ^= x;
                l = (l + 1) >> 1;
                r = (r - 1) >> 1;
            }
        }
        int get(int i) {
            for (int l = 0, r = N - 1, v = 1; ; ) {
                if (l == r)
                    return T[v];
                T[2 * v] ^= T[v];
                T[2 * v + 1] ^= T[v];
                T[v] = 0;
                if (i <= (l + r) / 2) {
                    r = (l + r) / 2;
                    v = 2 * v;
                } else {
                    l = (l + r) / 2 + 1;
                    v = 2 * v + 1;
                }
            }
        }
    }

    final int K = 30;
    int[] tmp = new int[50 * K];
    int tn = 0;
    int gauss(int[] C) {
        int pt = 0;
        for (int i = 0; i < K; i++) {
            int ind = -1;
            for (int j = pt; j < tn; j++) {
                if (((tmp[j] >> i) & 1) == 1)
                    ind = j;
            }
            if (ind == -1)
                continue;
            C[pt] = tmp[ind];
            tmp[ind] = tmp[pt];
            for (int j = pt + 1; j < tn; j++)
                if (((tmp[j] >> i) & 1) == 1)
                    tmp[j] ^= C[pt];
            pt++;
        }
        return pt;
    }

    int merge(int[] A, int apt, int[] B, int bpt, int[] C) {
        tn = 0;
        for (int i = 0; i < apt; i++) {
            if (A[i] == 0)
                break;
            tmp[tn++] = A[i];
        }
        for (int i = 0; i < bpt; i++) {
            if (B[i] == 0)
                break;
            tmp[tn++] = B[i];
        }
        return gauss(C);
    }

    void write(int[] A, int len) {
        for (int i = 0; i < len; i++)
            tmp[tn++] = A[i];
    }

    class BasisSegmentTree {
        int[][] T;
        int[] Tpt;
        int N = 1;

        BasisSegmentTree(int n) {
            while (N < n)
                N <<= 1;
            T = new int[2 * N][K];
            Tpt = new int[2 * N];
        }

        void init() {
            for (int i = N - 1; i > 0; i--)
                Tpt[i] = merge(T[2 * i], Tpt[2 * i], T[2 * i + 1], Tpt[2 * i + 1], T[i]);
        }

        void update(int x, int v) {
            if (x < 0 || x >= N)
                return;
            x += N;
            T[x][0] ^= v;
            Tpt[x] = (T[x][0] == 0) ? 0 : 1;
            while ((x >>= 1) > 0)
                Tpt[x] = merge(T[2 * x], Tpt[2 * x], T[2 * x + 1], Tpt[2 * x + 1], T[x]);
        }
        void get(int l, int r) {
            l += N;
            r += N;
            int tpt = 0;
            tn = 0;
            while (l <= r) {
                if ((l & 1) == 1)
                    write(T[l], Tpt[l]);
                if ((r & 1) == 0)
                    write(T[r], Tpt[r]);
                l = (l + 1) >> 1;
                r = (r - 1) >> 1;
            }
        }
    }

    public void run() {
        int n = reader.nextInt();
        int q = reader.nextInt();

        FixedPointSegmentTree T = new FixedPointSegmentTree(n);
        BasisSegmentTree B = new BasisSegmentTree(n - 1);

        int lst = 0;
        for (int i = 0; i < n; i++) {
            int t = reader.nextInt();
            T.T[T.N + i] = t;
            if (i > 0) {
                B.T[B.N + i - 1][0] = t ^ lst;
                B.Tpt[B.N + i - 1] = ((t ^ lst) > 0) ? 1 : 0;
            }
            lst = t;
        }
        B.init();
        int[] to = new int[K];
        for (int i = 0; i < q; i++) {
            int t = reader.nextInt();
            if (t == 1) {
                int l = reader.nextInt() - 1;
                int r = reader.nextInt() - 1;
                int x = reader.nextInt();
                B.update(l - 1, x);
                B.update(r, x);
                T.add(l, r, x);
            } else {
                int l = reader.nextInt() - 1;
                int r = reader.nextInt() - 1;
                B.get(l, r - 1);
                tmp[tn++] = T.get(l);
                int res = gauss(to);
                writer.printf("%d\n", 1 << res);
            }
        }
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}