#include <bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long long ll;
#define PB push_back
const ll M = 2e5+7;

vector<vector<ll> > edg(M), levelOrder(M), BIT(M);
ll val[M], llime[M], outTime[M], nodeLevel[M];
bool visited[M];

ll bitSum(vector<ll> &arr, ll pos){
    ll sum = 0;
    while(pos>0){
        sum += arr[pos];
        pos -= (pos & (-pos));
    }
    return sum;
}

void bitUpdate(vector<ll> &arr, ll pos, ll val){
    while(pos<(ll)arr.size()){
        arr[pos] += val;
        pos += (pos & (-pos));
    }
}

bool compllime(ll node1, ll node2){
    return llime[node1]<llime[node2];
}

bool compOutTime(ll node1, ll node2){
    return outTime[node1]<outTime[node2];
}

ll dfs(ll node, ll level, ll time){

    visited[node] = true;
    nodeLevel[node] = level;
    levelOrder[level].PB(node);
    llime[node] = time;

    for (auto x : edg[node]){
        if (visited[x])
            continue;
        time = dfs(x, level+1, time+1);
    }
    return outTime[node] = time + 1;
}

int main(){
    fast;
    ll n,a,b;
    cin>>n;
    for (ll i = 1; i < n; i++){
        cin>>a>>b;
        edg[a].PB(b);
        edg[b].PB(a);
    }
    for (ll i = 1; i <= n; i++)
        cin>>val[i];
    dfs(1,0,0);

    for (ll i = 0; ; i++){
        if (levelOrder[i].size() == 0)
            break;
        sort(levelOrder[i].begin(), levelOrder[i].end(), compllime);
        BIT[i].resize(levelOrder[i].size() + 1);
        for (ll j = 0; j<(ll)levelOrder[i].size(); j++){
            bitUpdate(BIT[i], j+1, val[levelOrder[i][j]] );
        }
    }
    ll q; 
    cin>>q; 
    while(q--){
        ll t, x, y;
        cin>>t>>x>>y;
        if (t == 1){
            ll pos = lower_bound(levelOrder[nodeLevel[x]].begin(), levelOrder[nodeLevel[x]].end(), x, compllime) - levelOrder[nodeLevel[x]].begin();
            bitUpdate(BIT[nodeLevel[x]], pos+1, -val[x]);
            val[x] = y;
            bitUpdate(BIT[nodeLevel[x]], pos+1, val[x]);
        }
        else{
            a = lower_bound(levelOrder[nodeLevel[x]+y].begin(), levelOrder[nodeLevel[x]+y].end(), x, compllime) - levelOrder[nodeLevel[x]+y].begin();
            b = upper_bound(levelOrder[nodeLevel[x]+y].begin(), levelOrder[nodeLevel[x]+y].end(), x, compOutTime) - levelOrder[nodeLevel[x]+y].begin() - 1;
            ll ans = bitSum(BIT[nodeLevel[x]+y], b+1) - bitSum(BIT[nodeLevel[x]+y], a);
            cout<<ans<<"\n";
        }
    }
    return 0;
}