/*
3secにしたほうがいいかもしれない
*/
#include <atcoder/segtree>
#include <iostream>
#include <vector>
#include <deque>
#include <stdio.h>
using namespace std;
using namespace atcoder;
#define ll long long

const ll bit_length=10;

typedef struct count{
  vector<ll> val;
  count(){
    val.resize(bit_length);
  }
}Counter;

ll restore(const Counter& a){
  ll ret=0,c=1;
  for(int i=0;i<bit_length;i++){
    ret+=c*a.val.at(i);
    c*=2;
  }
  return ret;
}


ostream& operator<<(ostream& os,const vector<Counter>& a){
  for(Counter i:a){
    os<<restore(i)<<" ";
  }
  return os;
}

ostream& operator<<(ostream& os,const vector<ll>& a){
  for(ll i:a){
    os<<i<<" ";
  }
  return os;
}

ostream& operator<<(ostream& os,const Counter& a){
  for(int i=bit_length-1;i>=0;i--){
    os<<a.val.at(i);
  }
  return os;
}

Counter change(ll a){
  Counter ret;
  for(int i=0;i<bit_length;i++){
    if((a>>i)&1)ret.val.at(i)=1;
    else ret.val.at(i)=0;
  }
  return ret;
}

Counter op(const Counter a,const Counter b){
  Counter ret;
  for(int i=0;i<bit_length;i++){
    ret.val.at(i)=a.val.at(i)+b.val.at(i);
  }
  //cerr<<a<<" "<<b<<" "<<ret<<endl;
  return ret;
}

Counter e(){
  Counter ret;
  for(int i=0;i<bit_length;i++){
    ret.val.at(i)=0;
  }
  return ret;
}

ll calculate(const Counter& a){
  ll ret=0,c=1;
  for(int i=0;i<bit_length;i++){
    ret+=c*((a.val.at(i)/2)%2);
    c*=2;
  }
  return ret;
}

Counter operator^(const Counter& a,const Counter& b){
  Counter ret;
  for(int i=0;i<bit_length;i++){
    ret.val.at(i)=a.val.at(i)^b.val.at(i);
  }
  return ret;
}

vector<vector<ll>>d;
vector<ll>depth;

int main(){
  ll N,Q,a,b,T,x,y,q;
  cin>>N>>Q;
  vector<ll>C(N);
  d.resize(N);
  depth.resize(N);
  for(int i=0;i<N;i++){
    cin>>C.at(i);
    depth.at(i)=0;
  }
  for(int i=0;i<N-1;i++){
    cin>>a>>b;
    d.at(a-1).push_back(b-1);
    d.at(b-1).push_back(a-1);
  }
  //要素の深さを計算する
  deque<ll> dq;
  vector<bool>B(N,false);
  dq.push_back(0);
  while(!dq.empty()){
    q=dq.back();dq.pop_back();
    B.at(q)=true;
    for(ll i:d.at(q)){
      if(B.at(i))continue;  
      dq.push_back(i);
      depth.at(i)+=depth.at(q)+1;
    }
  }
  //子と親に分ける
  vector<vector<ll>> parents(N);
  vector<vector<ll>> children(N);
  for(int i=0;i<N;i++){
    for(ll j:d.at(i)){
      if(depth.at(i)<depth.at(j))children.at(i).push_back(j);
      else parents.at(i).push_back(j);
    }
  }
  //cerr<<C<<endl;
  ll next,now=0;
  vector<vector<ll>> Nodes(N);
  vector<Counter> A;
  vector<bool> check(N,false);//初めてきたか
  while(1){
    //cerr<<"now:"<<now+1<<" ";
    if(!check.at(now)){
      //初めて来たらpush
      //cerr<<"push "<<C.at(now)<<" "<<change(C.at(now))<<" ";
      Nodes.at(now).push_back(A.size());
      A.push_back(change(C.at(now)));
      check.at(now)=true;
    }
    if(!children.at(now).empty()){
      //進む
      //cerr<<"go\n";
      next=children.at(now).back();
      children.at(now).pop_back();
    }else if(!parents.at(now).empty()){
      //戻る
      //戻るときもpush
      //cerr<<"back "<<C.at(now)<<" "<<change(C.at(now))<<endl;
      Nodes.at(now).push_back(A.size());
      A.push_back(change(C.at(now)));
      next=parents.at(now).back();
    }else{
      //親がない->根
      //cerr<<"break "<<C.at(now)<<" "<<change(C.at(now))<<endl;
      Nodes.at(now).push_back(A.size());
      A.push_back(change(C.at(now)));
      break;
    }
    now=next;
  }
  //cerr<<A<<endl;
  //頂点が2つあることを忘れないようにする
  segtree<Counter,op,e> seg(A);
  ll r,l;
  Counter R,L,P;
  for(int i=0;i<Q;i++){
    cin>>T>>x>>y;
    if(T==1){
      x--;
      l=Nodes.at(x).at(0);
      r=Nodes.at(x).at(1);
      //cerr<<"l:"<<l<<",r:"<<r<<endl;
      L=seg.get(l);
      R=seg.get(r);
      seg.set(l,L^change(y));
      seg.set(r,R^change(y));
    }else{
      x--;
      l=Nodes.at(x).at(0);
      r=Nodes.at(x).at(1);
      //cerr<<"l:"<<l<<",r:"<<r<<endl;
      P=seg.prod(l,r+1);
      //cerr<<"P:"<<P<<endl;
      printf("%lld\n",calculate(P));
    }
  }
  // for(int i=0;i<2*N;i++){
  //   cerr<<restore(seg.get(i))<<" ";
  // }
  return 0;
}