void access(int x) {
    for (int y = 0; x; y = x, x = t[x].fa) {  // y 是上一步的 x，用于连接
        splay(x);           // 先把 x 旋转到它所在 Splay 的根
        t[x].ch[1] = y;     // 把原来的右儿子换成 y（新的虚边变实）
        pushup(x);          // 更新 x 的 sum 信息
    }
}

void makeroot(int x) {
    access(x);
    splay(x);
    pushrev(x);   // 翻转 x 所在 Splay 树
}

int findroot(int x) {
    access(x);
    splay(x);
    while (t[x].ch[0]) {        // 一直向左走，直到没有左孩子
        pushdown(x);            // 下传翻转标记，保证方向正确
        x = t[x].ch[0];
    }
    splay(x);                   // 把根旋转到 Splay 的根，加速后续操作
    return x;
}

void link(int x, int y) {
    makeroot(x);
    if (findroot(y) != x) {   // 确保不在同一棵树
        t[x].fa = y;          // 虚边连接：x 挂在 y 下面
    }
}

void cut(int x, int y) {
    makeroot(x);               // 先让 x 成为根
    if (findroot(y) == x &&    // y 和 x 在同一棵树
        t[y].fa == x &&        // y 的父亲就是 x
        !t[y].ch[0]) {         // y 没有左孩子（说明 y 在 Splay 中是 x 的直接右孩子）
        t[x].ch[1] = 0;        // 断开 x 的右孩子
        t[y].fa = 0;           // 清空 y 的父亲
        pushup(x);             // 更新 x 的 sum
    }
}

void split(int x, int y) {
    makeroot(x);
    access(y);
    splay(y);
}

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

struct Node {
    int ch[2];   // 左右孩子，0:左，1:右
    int fa;      // 父节点（在Splay树中），如果是虚边，fa指向路径外节点
    int rev;     // 翻转标记（0或1）
    int val;     // 节点权值
    int sum;     // 子树异或和（包括自身）
} t[100005];     // 节点数组，节点编号从1到n，0表示空

int n, m;

// 判断 x 是不是所在Splay树的根（即没有父节点或父节点的左右孩子都不是它）
bool isroot(int x) {
    return t[t[x].fa].ch[0] != x && t[t[x].fa].ch[1] != x;
}

// 更新 x 的 sum：左子树异或和 ^ 右子树异或和 ^ 自身权值
void pushup(int x) {
    t[x].sum = t[t[x].ch[0]].sum ^ t[t[x].ch[1]].sum ^ t[x].val;
}

// 翻转 x 所在子树（交换左右孩子，并打上标记）
void pushrev(int x) {
    swap(t[x].ch[0], t[x].ch[1]);
    t[x].rev ^= 1;
}

// 下传翻转标记（如果有，则向下传递）
void pushdown(int x) {
    if (t[x].rev) {
        if (t[x].ch[0]) pushrev(t[x].ch[0]);  // 左子树翻转
        if (t[x].ch[1]) pushrev(t[x].ch[1]);  // 右子树翻转
        t[x].rev = 0;                         // 清除自身标记
    }
}

// 旋转：将 x 向上旋转一层（左旋或右旋）
void rotate(int x) {
    int y = t[x].fa, z = t[y].fa;       // y 是 x 的父，z 是爷爷
    int k = (t[y].ch[1] == x);          // k=0表示x是左孩子，k=1表示右孩子
    if (!isroot(y)) t[z].ch[t[z].ch[1] == y] = x; // 如果y不是根，更新爷爷的孩子
    t[x].fa = z;                        // 更新x的父亲为z

    t[y].ch[k] = t[x].ch[k ^ 1];       // 把x的另一个孩子给y
    if (t[x].ch[k ^ 1]) t[t[x].ch[k ^ 1]].fa = y;

    t[x].ch[k ^ 1] = y;                // y成为x的对应孩子
    t[y].fa = x;

    pushup(y); pushup(x);               // 更新信息
}

// 把 x 旋转到所在Splay树的根（一路向上splay）
void splay(int x) {
    // 因为旋转时会改变父节点关系，需要先把从根到x路径上的所有翻转标记下传
    stack<int> stk;
    int y = x;
    stk.push(y);
    while (!isroot(y)) {                // 把路径上的节点存入栈
        y = t[y].fa;
        stk.push(y);
    }
    while (!stk.empty()) {              // 从根到x依次下传
        pushdown(stk.top());
        stk.pop();
    }

    while (!isroot(x)) {
        int y = t[x].fa, z = t[y].fa;
        if (!isroot(y)) {               // 如果y不是根，需要判断旋转类型
            if ((t[z].ch[0] == y) ^ (t[y].ch[0] == x)) rotate(x); // 之字形
            else rotate(y);             // 一字型
        }
        rotate(x);
    }
    // 此时x已经是Splay树的根
}

// 以下五个操作前面已经详细解释
void access(int x) {
    for (int y = 0; x; y = x, x = t[x].fa) {
        splay(x);
        t[x].ch[1] = y;
        pushup(x);
    }
}

void makeroot(int x) {
    access(x);
    splay(x);
    pushrev(x);
}

int findroot(int x) {
    access(x);
    splay(x);
    while (t[x].ch[0]) {
        pushdown(x);
        x = t[x].ch[0];
    }
    splay(x);
    return x;
}

void split(int x, int y) {
    makeroot(x);
    access(y);
    splay(y);
}

void link(int x, int y) {
    makeroot(x);
    if (findroot(y) != x) {
        t[x].fa = y;
    }
}

void cut(int x, int y) {
    makeroot(x);
    if (findroot(y) == x && t[y].fa == x && !t[y].ch[0]) {
        t[x].ch[1] = 0;
        t[y].fa = 0;
        pushup(x);
    }
}

int main() {
    scanf("%d%d", &n, &m);            // 读入节点数n，操作数m
    for (int i = 1; i <= n; i++) {
        scanf("%d", &t[i].val);       // 读入每个节点的初始权值
        t[i].sum = t[i].val;          // 初始sum等于自身权值
    }
    while (m--) {
        int op, x, y;
        scanf("%d%d%d", &op, &x, &y);
        if (op == 1) {
            link(x, y);
        } else if (op == 2) {
            cut(x, y);
        } else if (op == 3) {
            split(x, y);
            printf("%d\n", t[y].sum); // 路径异或和
        }
    }
    return 0;
}