#include <bits/stdc++.h>

using namespace std;

const int N = int(2e5);
const int Q = int(5e5);
const int L = 18;

int n, q;

int dfn[N], dfo[N], idx[N];

int pr[N][L], dep[N], logs[N], from[N];
int64_t d[N];
pair<int, int> sparse[N][L];

vector<pair<int, int>> g[2][N];

int LCA(int u, int v) {
  if (from[u] > from[v]) {
    swap(u, v);
  }
  int k = logs[from[v] - from[u] + 1];
  return min(sparse[from[u]][k], sparse[from[v] - (1 << k) + 1][k]).second;
}

int64_t fenw[N];

void Modify(int p, int v) {
  while (p < n) {
    fenw[p] += v;
    p |= (p + 1);
  }
}

int64_t Query(int p) {
  int64_t v = 0;
  while (p >= 0) {
    v += fenw[p];
    p = (p & (p + 1)) - 1;
  }
  return v;
}

void Update(int l, int r, int v) {
  Modify(l, v);
  Modify(r + 1, -v);
}

int64_t GetDist(int u, int v) {
  return d[u] + d[v] - 2 * d[LCA(u, v)] + Query(dfn[u]) + Query(dfn[v]);
}

struct Diam {
  int x, y;
  Diam(int ver = 0) : x(ver), y(ver) {}
};

Diam Merge(Diam a, Diam b) {
  Diam ret = GetDist(a.x, a.y) > GetDist(b.x, b.y) ? a : b;
  long long d = GetDist(ret.x, ret.y);
  for (int x : {a.x, a.y}) {
    for (int y : {b.x, b.y}) {
      long long c = GetDist(x, y);
      if (d < c) {
        ret.x = x;
        ret.y = y;
        d = c;
      }
    }
  }
  return ret;
}

Diam st[8 * N];

void Build(int id, int l, int r) {
  if (l == r) {
    st[id] = Diam(idx[l]);
    return;
  }
  int mid = l + r >> 1;
  Build(id * 2, l, mid);
  Build(id * 2 + 1, mid + 1, r);
  st[id] = Merge(st[id * 2], st[id * 2 + 1]);
}

void Recalc(int id, int l, int r, int ll, int rr) {
  if (ll <= l && r <= rr) {
    return;
  }
  int mid = l + r >> 1;
  if (rr <= mid) {
    Recalc(id * 2, l, mid, ll, rr);
  } else if (ll > mid) {
    Recalc(id * 2 + 1, mid + 1, r, ll, rr);
  } else {
    Recalc(id * 2, l, mid, ll, rr);
    Recalc(id * 2 + 1, mid + 1, r, ll, rr);
  }
  st[id] = Merge(st[id * 2], st[id * 2 + 1]);
}

int64_t Calc(int v, int u) {
  return d[v] + d[u] - 2 * d[LCA(u, v)] + Query(dfn[u]);
}

int qa[Q], qb[Q];

int64_t res[Q];

vector<int> qs[N];

void Solve(int v, int pv) {
  for (int i : qs[v]) {
    res[i] = max(Calc(qb[i], st[1].x), Calc(qb[i], st[1].y));
  }
  for (auto& p : g[0][v]) {
    int to = p.first;
    int w = p.second;
    if (to == pv) {
      continue;
    }
    Update(0, n - 1, +w);
    Update(dfn[to], dfo[to], -2 * w);
    Recalc(1, 0, n - 1, dfn[to], dfo[to]);
    Solve(to, v);
    Update(dfn[to], dfo[to], +2 * w);
    Update(0, n - 1, -w);
    Recalc(1, 0, n - 1, dfn[to], dfo[to]);
  }
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cin >> n >> q;
  for (int t = 0; t < 2; t++) {
    for (int i = 1; i < n; i++) {
      int u, v, w;
      cin >> u >> v >> w;
      --u; --v;
      g[t][u].emplace_back(v, w);
      g[t][v].emplace_back(u, w);
    }
  }
  {
    int T = -1;
    auto Dfs = [&](auto&& self, int v, int pv) -> void {
      dfn[v] = ++T;
      idx[dfn[v]] = v;
      for (auto& p : g[0][v]) {
        int to = p.first;
        if (to == pv) {
          continue;
        }
        self(self, to, v);
      }
      dfo[v] = T;
    };
    Dfs(Dfs, 0, 0);
  }
  {
    int ptr = 0;
    auto Dfs = [&](auto&& self, int v, int pv) -> void {
      dep[v] = dep[pv] + 1;
      pr[v][0] = pv;
      for (int i = 1; i < L; i++) {
        pr[v][i] = pr[pr[v][i - 1]][i - 1];
      }
      from[v] = ptr;
      sparse[ptr][0] = make_pair(dep[v], v);
      ptr += 1;
      for (auto& p : g[1][v]) {
        int to = p.first;
        int w = p.second;
        if (to == pv) {
          continue;
        }
        d[to] = d[v] + w;
        sparse[ptr][0] = make_pair(dep[v], v);
        ptr += 1;
        self(self, to, v);
      }
    };
    Dfs(Dfs, 0, 0);
    for (int i = 2; i < N; i++) {
      logs[i] = logs[i >> 1] + 1;
    }
    for (int j = 1; j < L; j++) {
      for (int i = 0; i + (1 << j) < N; i++) {
        sparse[i][j] = min(sparse[i][j - 1], sparse[i + (1 << (j - 1))][j - 1]);
      }
    }
  }
  auto Dfs0 = [&](auto&&self, int v, int pv) -> void {
    for (auto& p : g[0][v]) {
      int to = p.first;
      int w = p.second;
      if (to == pv) {
        continue;
      }
      Update(dfn[to], dfo[to], w);
      self(self, to, v);
    }
  };
  Dfs0(Dfs0, 0, 0);
  Build(1, 0, n - 1);
  for (int i = 0; i < q; i++) {
    cin >> qa[i] >> qb[i];
    --qa[i]; --qb[i];
  }
  for (int i = 0; i < q; i++) {
    qs[qa[i]].push_back(i);
  }
  Solve(0, 0);
  for (int i = 0; i < q; i++) {
    cout << res[i] << '\n';
  }
  return 0;
}