#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define pb emplace_back
#define mp make_pair
#define fi first
#define se second
typedef vector<int> vi;
typedef pair<int,int> pi;

using i64=unsigned long long;
void chmax(i64 &x,i64 y){
	if(y>x){
		x=y;
	}
}

const int N=1e5+5;
int n, q;
namespace tree0{
	vector<pi> G[N];
	int dfn[N], dfc;
	i64 dep[N];
	int mn[17][N];
	
	void link(int u,int v,int w){
		G[u].pb(v, w);
		G[v].pb(u, w);
	}
	void dfs(int u,int p){
		dfn[u]=++dfc;
		mn[0][dfc]=p;
		for(auto [v,w]:G[u]){
			if(v!=p){
				dep[v]=dep[u]+w;
				dfs(v, u);
			}
		}
	}
	int get(int u,int v){
		return dfn[u]<dfn[v]? u: v;
	};
	void init(){
		dfs(1, 0);
		rep(i,1,16){
			rep(j,1,n-(1<<i)+1){
				mn[i][j]=get(mn[i-1][j], mn[i-1][j+(1<<(i-1))]);
			}
		}
	}
	int LCA(int u,int v){
		if(u==v){
			return u;
		}
		if((u=dfn[u])>(v=dfn[v])){
			swap(u, v);
		}
		int lg=__lg(v-(u++));
		return get(mn[lg][u], mn[lg][v-(1<<lg)+1]);
	}
	i64 dis(int u,int v){
		return dep[u]+dep[v]-dep[LCA(u,v)]*2;
	}

	void clear(){
		rep(i,1,n){
			G[i].clear();
		}
		dfc=0;
	}
}

using tree0::dis;

namespace tree1{
	struct D{
		int u, v;
		i64 d, tagu, tagv;
		
		void ins(int c,i64 ext){
			if(u==0){
				u=v=c, d=0, tagu=tagv=ext;
			}
			else{
				i64 du=dis(u, c), dv=dis(v, c);
				if(du+tagu<dv+tagv){
					swap(u, v);
					swap(du, dv);
					swap(tagu, tagv);
				}
				if(du+ext>d+tagv){
					d=du, v=c, tagv=ext;
				}
			}
		}
		i64 val(){
			return d+tagu+(u!=v)*tagv;
		}
	};
	
	vector<pi> G[N];
	D f[N], g[N], pre[N], suf[N];
	void link(int u,int v,int w){
		G[u].pb(v, w);
		G[v].pb(u, w);
	}
	void dfs0(int u,int p){
		f[u]={u, u, 0, 0, 0};
		for(auto [v,w]:G[u]){
			if(v!=p){
				dfs0(v, u);
				f[u].ins(f[v].u, f[v].tagu+w);
				f[u].ins(f[v].v, f[v].tagv+w);
			}
		}
	}
	void dfs1(int u,int p){
		D cur{0, 0, 0, 0, 0};
		rep(i,0,(int)G[u].size()-1){
			int v=G[u][i].fi, w=G[u][i].se;
			if(v!=p){
				pre[v]=cur;
				cur.ins(f[v].u, f[v].tagu+w);
				cur.ins(f[v].v, f[v].tagv+w);
			}
		}
		cur={0, 0, 0, 0, 0};
		per(i,(int)G[u].size()-1,0){
			int v=G[u][i].fi, w=G[u][i].se;
			if(v!=p){
				suf[v]=cur;
				cur.ins(f[v].u, f[v].tagu+w);
				cur.ins(f[v].v, f[v].tagv+w);
			}
		}
		for(auto [v,w]:G[u]){
			if(v!=p){
				g[v]=g[u];
				if(pre[v].u!=0){
					g[v].ins(pre[v].u, pre[v].tagu+w);
					g[v].ins(pre[v].v, pre[v].tagv+w);
				}
				if(suf[v].u!=0){
					g[v].ins(suf[v].u, suf[v].tagu+w);
					g[v].ins(suf[v].v, suf[v].tagv+w);
				}
				dfs1(v, u);
			}
		}
	}
	i64 qry(int u,int v){
		// cout<<g[u].u<<' '<<g[u].v<<'\n';
		i64 ans=0;
		rep(i,0,1){
			chmax(ans, dis(v, (i? f[u].v: f[u].u))+(i? f[u].tagv: f[u].tagu) );
			if(u!=1) chmax(ans, dis(v, (i? g[u].v: g[u].u))+(i? g[u].tagv: g[u].tagu) );
		}
		return ans;
	}
	
	void clear(){
	}
}

void solve(){
	cin>>n>>q;
	rep(i,1,n-1){
		int u,v,w; cin>>u>>v>>w;
		tree0::link(u, v, w);
	}
	tree0::init();
	rep(i,1,n-1){
		int u,v,w; cin>>u>>v>>w;
		tree1::link(u, v, w);
	}
	tree1::dfs0(1, 0);
	tree1::dfs1(1, 0);
	rep(i,1,q){
		int u,v; cin>>u>>v;
		cout<< tree1::qry(v, u) <<'\n';
	}

	tree0::clear();
	tree1::clear();
}
signed main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	
	int t=1;
	while(t--){
		solve();
	}
}