#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;

template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (ll i=(ll)from; i<(ll)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (int i=(int)N-1; i>=0; i--)

const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;

vector<ll> fac;
void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }
ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }
ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }

// ----------------------------------------------------------------------
// ----------------------------------------------------------------------

struct stp {
  ll i, d; 
  bool operator< (const stp &x) const { return d<x.d||(d==x.d&&i<x.i); };
};

struct SegTree {
  int size;
  vector<stp> pos;
  // SegTree(ll N) { size = 1; while(size<N) size<<=1; pos.resize(2*size,{0,0}); }
  stp operator[](const ll &x) const { return pos[x+size]; }

  void build() { per(i,size) operate(i); }
  void init(ll N) { size = 1; while(size<N) size<<=1; pos.resize(2*size,{0,0}); }
  void set(ll x, const stp v) { pos[x+size] = v; }
  void update(ll x, const stp v) { set(x,v); x+=size; while (x>>=1) operate(x); }
  ll query(ll a, ll b) {
    stp L = {-1,LLINF}, R = {-1,LLINF};
    for (a+=size, b+=size; a<b; a>>=1, b>>=1) {
      if (a&1) { L = q(L,pos[a]); a++; }
      if (b&1) { b--; R = q(R,pos[b]); }
    }
    return q(L,R).i;
  }
  void operate(ll i) { pos[i] = min(pos[i*2], pos[i*2+1]); }
  stp q(stp x, stp y) { return min(x, y); }
};

// ----------------------------------------------------------------------
// ----------------------------------------------------------------------

struct edge { ll to, i, d; };
vector<vector<edge>> adj;

struct range { ll l, r, d; };
vector<range> ran;
vector<stp> tour;
SegTree st;

ll LCA(ll x, ll y) {
  if (ran[x].l<ran[y].l) return st.query(ran[x].l, ran[y].r);
  else return st.query(ran[y].l, ran[x].r);
}

void dfs(ll n, ll p, ll d) {
  ran[n].l = tour.size();
  ran[n].d = d;
  tour.push_back({n,d});
  for (auto x: adj[n]) {
    if (x.to==p) continue;
    dfs(x.to,n,d+1);
    tour.push_back({n,d});
  }
  ran[n].r = tour.size();
}

void EulerTour(ll n=0) {
  ran.resize(adj.size(),{LLINF,-1*LLINF,-1});
  ll d = 0; dfs(n,-1,d);
  st.init(tour.size());
  rep(i,tour.size()) st.update(i, tour[i]);
}

// ----------------------------------------------------------------------
// ----------------------------------------------------------------------

vector<ll> d;
void calc_d(ll n=0, ll p=-1) {
  if (n==0) d[0] = 0;
  for (auto x: adj[n]) {
    if (x.to==p) continue;
    d[x.to] = d[n] + x.d;
    calc_d(x.to,n);
  }
}

int main() {
  ll N; cin >> N;
  adj.resize(N);
  rep(i,N-1) { 
    ll u, v, w; cin >> u >> v >> w;
    adj[u].push_back({v,i,w}); adj[v].push_back({u,i,w});
  }
  d.resize(N); calc_d();
  // debug(all(d));

  EulerTour();
  ll Q; cin >> Q;
  rep(_,Q) {
    ll x, y, z; cin >> x >> y >> z;
    ll xy = d[x] + d[y] - d[LCA(x,y)]*2;
    ll yz = d[y] + d[z] - d[LCA(y,z)]*2;
    ll zx = d[z] + d[x] - d[LCA(z,x)]*2;
    ll result = (xy+yz+zx)/2;
    // cout << xy << " " << yz << " " << zx << endl;
    cout << result << endl;
  }
  return 0;
}