#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
using namespace std;
#define REP(i,m,n) for(int i=(int)m ; i < (int) n ; ++i )
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,int> pli;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
int dx[4]={1,0,-1,0} , dy[4]={0,1,0,-1} ;
 
struct LazySegmentTree{
private:
   int n;
   vector<ll> node,lazy;
public:
   LazySegmentTree(int sz,ll init=0){
      n=1;
      while(n<sz)n*=2;
      node.resize(2*n-1,init);
      lazy.resize(2*n-1,0);
   }
 
   void eval(int k,int l,int r){
      if(lazy[k]!=0)node[k]+=lazy[k];
      if(r-l>1){
          lazy[2*k+1]+=lazy[k]/2;
          lazy[2*k+2]+=lazy[k]/2;
      }
      lazy[k]=0;
   }
      //[a,b)にxを加算
   void add(int a,int b,ll x,int k=0,int l=0,int r=-1){
       if(r<0)r=n;
       eval(k,l,r);
       if(r<=a||b<=l)return;
       if(a<=l&&r<=b){
          lazy[k]+=(r-l)*x;
          eval(k,l,r);
       }
       else {
          add(a,b,x,2*k+1,l,(l+r)/2);
          add(a,b,x,2*k+2,(l+r)/2,r);
          node[k]=node[2*k+1]+node[2*k+2];
        }
   }
   //[a,b)での和を返す
   ll get(int a,int b,int k=0,int l=0,int r=-1){
      if(r<0)r=n;
      eval(k,l,r);
      if(r<=a||b<=l)return 0;
      if(a<=l&&r<=b)return node[k];
      ll xl=get(a,b,2*k+1,l,(l+r)/2);
      ll xr=get(a,b,2*k+2,(l+r)/2,r);
      return xl+xr;
   }
};
 
LazySegmentTree sg(151515);
 
struct HLDecomposition{
    int n,pos;
    vector<vector<int>> v;
    vector<int> idx,head,sz,hvy,par,depth,inv,type;
 
    HLDecomposition(){};
    HLDecomposition(int s):
        n(s),pos(0),v(n),idx(n,-1),head(n),sz(n,1),
        hvy(n,-1),par(n),depth(n),inv(n),type(n){}
     
    void addedge(int x,int y){
        v[x].push_back(y);
        v[y].push_back(x);
    }
 
    void dfs1(int rt){
        par[rt]=-1;
        depth[rt]=0;
        stack<pint> st;
        st.push({rt,0});
        while(!st.empty()){
            int x=st.top().first;
            int& i=st.top().second;
            if(i<(int)v[x].size()){
                int to=v[x][i++];
                if(to==par[x])continue;
                par[to]=x;
                depth[to]=depth[x]+1;
                st.push({to,0});
            }
            else {
                st.pop();
                int res=0;
                for(int to:v[x]){
                    if(to==par[x])continue;
                    sz[x]+=sz[to];
                    if(sz[to]>res)res=sz[to],hvy[x]=to;
                }
            }
        }
    }
    void dfs2(int r,int c){
        int &k=pos;
        stack<int> st;
        st.push(r);
        while(!st.empty()){
            int h=st.top();st.pop();
            for(int x=h;x!=-1;x=hvy[x]){
                type[x]=c;
                head[x]=h;
                idx[x]=k++;
                inv[idx[x]]=x;
                for(int to:v[x])
                    if(to!=par[x]&&to!=hvy[x])st.push(to);
            }
        }
    }
 
    void build(vector<int> rs=vector<int>(1,0)){
        int c=0;
        for(int r:rs){
            dfs1(r);
            dfs2(r,c++);
        }
    }
    ll f(int x,int y){
        //ここに何か書く！！！
        return sg.get(x,y+1);
    }
 
    void for_v(int x,int y){
        while(1){
            if(idx[x]>idx[y])swap(x,y);
            f(max(idx[head[y]],idx[x]),idx[y]);
            if(head[x]!=head[y])y=par[head[y]];
            else break;
        }
    }
 
    ll for_edge(int x,int y){
        ll ret=0;
        while(1){
            if(idx[x]>idx[y])swap(x,y);
            if(head[x]!=head[y]){
                ret+=f(idx[head[y]],idx[y]);
                y=par[head[y]];
            }
            else{
                if(x!=y)ret+=f(idx[x]+1,idx[y]);
                break;
            }
        }
        return ret;
    }
    int lca(int x,int y){
        while(1){
            if(idx[x]>idx[y])swap(x,y);
            if(head[x]==head[y])return x;
            y=par[head[y]];
        }
    }
 
    int dist(int x,int y){
        return depth[x]+depth[y]-2*depth[lca(x,y)];
    }
};
int main(){
    int n,q;
    cin>>n;
    HLDecomposition hl(n);
	vector<int> x(n-1),y(n-1),z(n-1);
    rep(i,n-1){
        scanf("%d %d %d",&x[i],&y[i],&z[i]);
        hl.addedge(x[i], y[i]);
    }
    hl.build();
	rep(i,n-1){
		if(hl.idx[x[i]]<hl.idx[y[i]]){
			sg.add(hl.idx[y[i]],hl.idx[y[i]]+1,z[i]);
		}
		else {
			sg.add(hl.idx[x[i]],hl.idx[x[i]]+1,z[i]);
		}
	}
	cin>>q;
    while(q--){
        int c,x,y;
        scanf("%d",&c);
        if(c==1){
			cin>>x>>y;
            int idx=hl.idx[x];
            sg.add(idx+1,idx+hl.sz[x],y);
        }
        else {
			cin>>x;
            printf("%lld\n",hl.for_edge(0, x));
        }
    }
   return 0;
}