#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using Graph1 = vector<vector<int>>;
#define rep(i,n) for(ll i=0;i<n;i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define all(x) (x).begin(),(x).end()
const ll INF = 1LL<<60;

// LCA(最近共通祖先)
struct LCA{
    vector<vector<int>> parent;
    vector<int> dist;
    LCA(const Graph1 &g, int root ) { init(g,root);}
    void init(const Graph1 &g,int root){
        int V = g.size();
        int K = 1;
        while((1<<K)<V) K++;
        parent.assign(K,vector<int>(V,-1));
        dist.assign(V,-1);
        bfs(g,root);
        for(int k=0;k+1<K;k++){
            for(int v=0;v<V;v++){
                if(parent[k][v]<0){
                    parent[k+1][v] = -1;
                }
                else{
                    parent[k+1][v] = parent[k][parent[k][v]];
                }
            }
        }
    }

    void bfs(const Graph1 &g,int v){
        int N = (int)g.size();
        queue<int> todo;
        parent[0][v] = -1;
        dist[v] = 0;
        todo.push(v);
        while(!todo.empty()){
            int pos = todo.front();
            todo.pop();
            for(int x:g[pos]){
                if(dist[x]!=-1) continue;
                parent[0][x] = pos;
                dist[x] = dist[pos]+1;
                todo.push(x);
            }
        }
    }

    int query(int u,int v){
        if(dist[u]<dist[v]) swap(u,v);
        int K = parent.size();
        for(int k = 0;k<K;k++){
            if((dist[u]-dist[v]) >> k&1){
                u = parent[k][u];
            }
        }
        if(u==v) return u;
        for(int k=K-1;k>=0;k--){
            if(parent[k][u]!=parent[k][v]){
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }
    int get_dist(int u,int v){
        return dist[u]+dist[v]-2*dist[query(u,v)];
    }
    bool is_on_path(int u,int v,int a){
        return get_dist(u,a)+get_dist(a,v) == get_dist(u,v);
    }
};

int main(){
    int n;
    cin >> n;
    Graph1 gr(n);
    vector<ll> Dist(n);
    vector<vector<pair<int,ll>>> gra(n);
    rep(i,n-1){
        int u,v;
        ll w;
        cin >>u >> v >> w;
        gr[u].push_back(v);
        gr[v].push_back(u);
        gra[u].push_back({v,w});
        gra[v].push_back({u,w});
    }
    LCA lca = LCA(gr,0);
    vector<ll> seen(n,-1);
    seen[0] = 0;
    queue<int> que;
    que.push(0);
    while(!que.empty()){
        int pos = que.front();
        que.pop();
        for(auto u:gra[pos]){
            if(seen[u.first]!=-1) continue;
            seen[u.first] = seen[pos]+u.second;
            que.push(u.first);
        }
    }
    int q;
    cin >> q;
    cout << endl;
    rep(i,q){
        int x,y,z;
        cin >> x >> y >> z;
        ll ans = 0;
        ans+=seen[x]+seen[y]-2*seen[lca.query(x,y)];
        ans+=seen[y]+seen[z]-2*seen[lca.query(y,z)];
        ans+=seen[z]+seen[x]-2*seen[lca.query(z,x)];
        cout << ans/2<<endl;
    }
}