#include<bits/stdc++.h>
#define file(F) freopen(#F".in","r",stdin),freopen(#F".out","w",stdout)
#define lowbit(x) ((x)&-(x))
#define ALL(x) (x).begin(),(x).end()
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define popc(x) (__builtin_popcountll((x)))
#define abs(x) ((x)>=0?(x):-(x))
using namespace std;
using ll=long long;
using uint=uint32_t;
template<typename T>
inline bool Max(T &x,T y) { return std::less<T>()(x,y)&&(x=y,true); }
template<typename T>
inline bool Min(T &x,T y) { return std::less<T>()(y,x)&&(x=y,true); }
void Solve();
const int N = 1e5+15;
int n,Q;
vector<pair<int,int>> e1[N],e2[N];
namespace GETLCA{
    #define pot(x) (1 << (x))

    const int M = 24;
    int tim,lg[N],dfn[N],dep[N],dp[N][M];

    inline void dfs(int u,int fa){
        dp[dfn[u] = ++tim][0] = dep[u];
        for (pair<int,int> v:e2[u]){
            if (v.first == fa) continue;
            dep[v.first] = dep[u] + v.second;
            dfs(v.first,u);
        }
        dp[++tim][0] = dep[u];
    }

    inline void init(){
        dfs(1,0);
        for (int i = 2;i <= tim;i++) lg[i] = lg[i >> 1] + 1;
        for (int j = 1;j <= lg[tim];j++){
            for (int i = 1;i + pot(j) - 1 <= tim;i++) dp[i][j] = min(dp[i][j - 1],dp[i + pot(j - 1)][j - 1]);
        }
    }

    inline int LCA(int x,int y){
        int sx = dfn[x],sy = dfn[y];
        if (sx > sy) swap(sx,sy);
        int t = lg[sy - sx + 1];
        return min(dp[sx][t],dp[sy - pot(t) + 1][t]);
    }

    inline int dis(int x,int y){
        return (dep[x] + dep[y] - 2 * LCA(x,y));
    }

    #undef pot
}
using GETLCA::LCA; using GETLCA::dis;
int dfn[N],pos[N],dfx,ed[N];
ll dep[N];
void dfs(int u,int fa) {
   pos[dfn[u]=++dfx]=u;
   for(auto [v,w]:e1[u]) if(v!=fa)
      dep[v]=dep[u]+w,dfs(v,u);
   ed[u]=dfx;
}
namespace SGT {
const int N = ::N<<2;
#define mid ((L+R)>>1)
#define ls (u<<1)
#define rs (ls|1)
struct Data {
   int a,b; ll wa,wb;
   static inline auto calc(const Data &x) {
      return x.a==x.b?0:dis(x.a,x.b)+x.wa+x.wb;
   };
   inline bool operator<(const Data &p) const {
      return calc(*this)<calc(p);
   }
   friend auto operator+(const Data &p,const Data &q) {
      Data T=max(p,q);
      Max(T,{p.a,q.a,p.wa,q.wa});
      Max(T,{p.a,q.b,p.wa,q.wb});
      Max(T,{p.b,q.a,p.wb,q.wa});
      Max(T,{p.b,q.b,p.wb,q.wb});
      return T;
   }
} mx[N];
ll tag[N];
void build(int u,int L,int R) {
   if(L==R) {
      int x=pos[L];
      mx[u]={x,x,dep[x],dep[x]};
      return ;
   }
   build(ls,L,mid),build(rs,mid+1,R);
   mx[u]=mx[ls]+mx[rs];
}
void update(int u,int L,int R,int l,int r,ll k) {
   if(l<=L&&R<=r) return void((tag[u]+=k,mx[u].wa+=k,mx[u].wb+=k));
   if(l<=mid) update(ls,L,mid,l,r,k);
   if(r> mid) update(rs,mid+1,R,l,r,k);
   mx[u]=mx[ls]+mx[rs];
   mx[u].wa+=tag[u],mx[u].wb+=tag[u];
}
}
vector<pair<int,int>> q[N];
ll ans[N*5];
void dfs1(int u,int fa) {
   auto res=SGT::mx[1];
   for(auto [v,id]:q[u]) ans[id]=max(dis(v,res.a)+res.wa,dis(v,res.b)+res.wb);
   for(auto [v,w]:e1[u]) if(v!=fa) {
      SGT::update(1,1,n,1,n,+w);
      SGT::update(1,1,n,dfn[v],ed[v],-w-w);
      dfs1(v,u);
      SGT::update(1,1,n,1,n,-w);
      SGT::update(1,1,n,dfn[v],ed[v],+w+w);
   }
}
signed main() {
#ifndef ONLINE_JUDGE
#endif
   cin.tie(nullptr)->sync_with_stdio(false);
   Solve();
}
void Solve() {
   cin>>n>>Q;
   for(int i=1;i<n;i++) {
      int u,v,w; cin>>u>>v>>w;
      e1[u].emplace_back(v,w),e1[v].emplace_back(u,w);
   }
   for(int i=1;i<n;i++) {
      int u,v,w; cin>>u>>v>>w;
      e2[u].emplace_back(v,w),e2[v].emplace_back(u,w);
   }
   for(int i=1;i<=Q;i++) {
      int a,b; cin>>a>>b;
      q[a].emplace_back(b,i);
   }
   GETLCA::init();
   dfs(1,0);
   SGT::build(1,1,n);
   dfs1(1,0);
   for(int i=1;i<=Q;i++) printf("%lld\n",ans[i]);
}