#include <bits/stdc++.h>
#define endl '\n'

using namespace std;

const int MAXN = 2e4 + 50;

struct Tree
{
    int n, root = 1, maxDepth = 0;
    vector <int> children[MAXN];
    vector <int> depth[MAXN];

    bool isNotLeaf[MAXN];
    int parent[MAXN];
    int dp[MAXN];
    int component[MAXN];

    int nodeValue[MAXN];
    int rootSubtrees[MAXN];

    Tree()
    {
        memset(parent, -1, sizeof(parent));
        memset(component, -1, sizeof(component));
        memset(isNotLeaf, false, sizeof(isNotLeaf));
    }

    Tree(int n):Tree()
    {
        this->n = n;
    }

    void AddEdge(int u, int v)
    {
        children[u].push_back(v);
        parent[v] = u;
        isNotLeaf[u] = true;
    }

    void SetValue(int node, int value)
    {
        dp[node] = value;
        nodeValue[node] = value;
    }

    void DFS(int node, int componentID, int d)
    {
        if (d > maxDepth)
            maxDepth = d;

        component[node] = componentID;
        depth[d].push_back(node);
        for (int i:children[node])
            DFS(i, componentID, d+1);
    }

    void CalculateDP()
    {
        int componentID = 1;
        for (int i:children[root])
        {
            rootSubtrees[componentID] = i;
            DFS(i, componentID, 1);
            componentID++;
        }

        while (maxDepth--)
        {
            for (int node:depth[maxDepth+1])
                dp[parent[node]] ^= dp[node];

        }

    }

    int Query(int node)
    {
        if (node == root)
            return nodeValue[root];

        int ans = nodeValue[root];
        ans ^= (dp[rootSubtrees[component[node]]]);
        ans ^= dp[node];

        ans ^= nodeValue[node];

        return ans;

    }

    void Update(int node, int value)
    {
        value = value^nodeValue[node];
        nodeValue[node] = value^nodeValue[node];

        while (node != -1)
        {
            dp[node] ^= value;
            node = parent[node];
        }

    }

};
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);

    #ifndef __LOCAL__
        freopen("xor.in", "r", stdin);
        freopen("xor.out", "w", stdout);
    #endif // __LOCAL__


    int n, q;
    cin >> n >> q;

    Tree tree(n);

    for (int i = 1; i <= n; i++)
    {
        int value;
        cin >> value;

        tree.SetValue(i, value);
    }

    for (int i = 1; i < n; i++)
    {
        int u, v;
        cin >> u >> v;

        tree.AddEdge(u, v);
    }

    tree.CalculateDP();

    for (int i = 0; i < q; i++)
    {
        int type;
        cin >> type;

        if (type == 1)
        {
            int node, value;
            cin >> node >> value;

            tree.Update(node, value);
        }

        else
        {
            int node;
            cin >> node;
            cout << tree.Query(node) << endl;
        }
    }

    return 0;
}

/*
4 3
1 2 4 8
1 2
2 3
3 4
2 4
1 2 5
2 3
*/