#include <bits/stdc++.h>
#define File(name) freopen(#name".in", "r", stdin); freopen(#name".out", "w", stdout);
using namespace std;
using ll = long long;
using ull = unsigned long long;
template<typename T>
inline T read(){
    T n = 0; int f = 1; char ch = getchar();
    while(!isdigit(ch)){
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(isdigit(ch)){
        n = n * 10 + ch - '0';
        ch = getchar();
    }
    return f * n;
}
template<typename T>
void write(T n){
    if(n < 0) return putchar('-'), write(-n);
    if(n / 10) write(n / 10);
    putchar(n % 10 + '0');
}
void input() {}
template<typename Type, typename... Types>
void input(Type &arg, Types &...args){
    arg = read<Type>();
    input(args...);
}
namespace Main{
    const int N = 100005;
    const int Q = 500005;
    int n, q, dfn[N], dfnCnt, st[17][N], dep[N], dfn2[N], id[N], dep2[N], siz[N], ans[Q];
    vector<pair<int, int>> g1[N], g2[N];
    vector<pair<int, int>> ask[N];
    void dfs(int u, int fa){
        st[0][dfn[u] = ++dfnCnt] = fa;
        for(auto [v, w]: g2[u]){
            if(v == fa) continue;
            dep[v] = dep[u] + w;
            dfs(v, u);
        }
    }
    inline int dmin(int u, int v) { return dep[u] < dep[v] ? u : v; }
    int lca(int u, int v){
        if(u == v) return u;
        if(dfn[u] > dfn[v]) swap(u, v);
        int lg = log2(dfn[v] - dfn[u]);
        return dmin(st[lg][dfn[u] + 1], st[lg][dfn[v] - (1 << lg) + 1]);
    }
    int dis(int u, int v){
        if(!u || !v) return 0;
        return dep[u] + dep[v] - 2 * dep[lca(u, v)];
    }
    struct segtree{
        struct segtree_node{
            int l, r;
            int add;
            pair<pair<int, int>, pair<int,int>> dia;
        }t[N << 2];
#define ls p << 1
#define rs p << 1 | 1
        void pushup(int p){
            vector<pair<int, int>> vec = {t[ls].dia.first, t[ls].dia.second, t[rs].dia.first, t[rs].dia.second};
            int len = 0;
            for(int i = 0; i < 4; i++){
                for(int j = i + 1; j < 4; j++){
                    int tmp = dis(vec[i].first, vec[j].first) + vec[i].second + vec[j].second;
                    if(tmp > len) t[p].dia = {vec[i], vec[j]}, len = tmp;
                }
            }
        }
        void pushadd(int p, int k){
            t[p].add += k;
            t[p].dia.first.second += k;
            t[p].dia.second.second += k;
        }
        void pushdown(int p){
            if(t[p].add){
                pushadd(ls, t[p].add);
                pushadd(rs, t[p].add);
                t[p].add = 0;
            }
        }
        void build(int p, int l, int r, int dep[]){
            t[p].l = l, t[p].r = r;
            if(l == r){
                t[p].dia.first = {id[l], dep[id[l]]};
                return;
            }
            int mid = t[p].l + t[p].r >> 1;
            build(ls, l, mid, dep), build(rs, mid + 1, r, dep);
            pushup(p);
        }
        void modify(int p, int l, int r, int k){
            if(l > r) return;
            if(t[p].l >= l && t[p].r <= r){
                pushadd(p, k);
                return;
            }
            int mid = t[p].l + t[p].r >> 1;
            pushdown(p);
            if(mid >= l) modify(ls, l, r, k);
            if(mid < r) modify(rs, l, r, k);
            pushup(p);
        }
        auto query() { return t[1].dia; }
#undef ls
#undef rs
    }tree;
    void dfs2(int u, int fa){
        dfn2[u] = ++dfnCnt;
        id[dfnCnt] = u;
        siz[u] = 1;
        for(auto [v, w]: g1[u]){
            if(v == fa) continue;
            dep2[v] = dep2[u] + w;
            dfs2(v, u);
            siz[u] += siz[v];
        }
    }
    void dfs3(int u, int fa){
        auto tmp = tree.query();
        for(auto [b, x]: ask[u]){
            ans[x] = max(dis(b, tmp.first.first) + tmp.first.second, dis(b, tmp.second.first) + tmp.second.second);
        }
        for(auto [v, w]: g1[u]){
            if(v == fa) continue;
            tree.modify(1, dfn[v], dfn[v] + siz[v] - 1, -w);
            tree.modify(1, 1, dfn[v] - 1, w);
            tree.modify(1, dfn[v] + siz[v], n, w);
            dfs3(v, u);
            tree.modify(1, dfn[v], dfn[v] + siz[v] - 1, w);
            tree.modify(1, 1, dfn[v] - 1, -w);
            tree.modify(1, dfn[v] + siz[v], n, -w);
        }
    }
    void Main(){
        input(n, q);
        for(int i = 1, u, v, w; i < n; i++){
            input(u, v, w);
            g1[u].emplace_back(v, w);
            g1[v].emplace_back(u, w);
        }
        for(int i = 1, u, v, w; i < n; i++){
            input(u, v, w);
            g2[u].emplace_back(v, w);
            g2[v].emplace_back(u, w);
        }
        dfs(1, 0);
        for(int i = 1; i < 17; i++){
            for(int j = 1; j + (1 << (i - 1)) <= n; j++){
                st[i][j] = dmin(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
            }
        }
        dfnCnt = 0;
        dfs2(1, 0);
        tree.build(1, 1, n, dep2);
        for(int i = 0, a, b; i < q; i++){
            input(a, b);
            ask[a].emplace_back(b, i);
        }
        dfs3(1, 0);
        for(int i = 0; i < q; i++) write(ans[i]), puts(""); 
        return;
    }
} // namespace Main
int main(){
#ifdef Liuxizai
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif // Liuxizai
    Main::Main();
    return 0;
}