#include <cctype>
#include <cstring>
#include <iostream>
#include <utility>
#include <vector>
constexpr int kB = 1 << 20;
char rbuf[kB + 1], *ps = rbuf + kB;
char Getchar() {
    if (ps - rbuf == kB)
        std::cin.read(rbuf, kB), ps = rbuf;

    return *ps++;
}
template <typename T = int>
T Read() {
    T x = 0;
    int f = 1;
    char c;

    while (!std::isdigit(c = Getchar()))
        if (c == '-')
            f = -1;

    x = c - '0';

    while (std::isdigit(c = Getchar()))
        x = x * 10 + c - '0';

    return x * f;
}
template <typename T>
void Read(T &x) {
    x = 0;
    int f = 1;
    char c;

    while (!std::isdigit(c = Getchar()))
        if (c == '-')
            f = -1;

    x = c - '0';

    while (std::isdigit(c = Getchar()))
        x = x * 10 + c - '0';

    x *= f;
}
template <typename T, typename... Args>
void Read(T &x, Args &...args) {
    Read(x), Read(args...);
}
template <typename T1, typename T2>
void checkmax(T1 &x, T2 y) {
    if (x < y)
        x = y;
}
template <typename T1, typename T2>
void checkmin(T1 &x, T2 y) {
    if (x > y)
        x = y;
}
struct Edge {
    int to, nxt, cost;
} e[600001];
int n, m, E, head[300001], dis[300001], dep[300001], fa[300001], sz[300001],
    son[300001], top[300001], w[300001], seq[300001], tot;
void Add(int f, int t, int c) {
    e[E] = {t, head[f], c}, head[f] = E++;
}
void Dfs(int u, int f) {
    sz[u] = 1, dep[u] = dep[fa[u] = f] + 1;

    for (int i = head[u]; i != -1; i = e[i].nxt) {
        int v = e[i].to, c = e[i].cost;

        if (v == f)
            continue;

        dis[v] = dis[u] + (w[v] = c), Dfs(v, u), sz[u] += sz[v];

        if (sz[v] > sz[son[u]])
            son[u] = v;
    }
}
void Dfs2(int u, int t) {
    seq[++tot] = u, top[u] = t;

    if (son[u])
        Dfs2(son[u], t);

    for (int i = head[u]; i != -1; i = e[i].nxt) {
        int v = e[i].to;

        if (v == fa[u] || v == son[u])
            continue;

        Dfs2(v, v);
    }
}
int GetLca(int u, int v) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]])
            std::swap(u, v);

        u = fa[top[u]];
    }

    return dep[u] < dep[v] ? u : v;
}
struct Route {
    int u, v, lca, len;
} b[300001];
int a[300001];
bool Check(int x) {
    int cnt = 0, lim = 0;
    std::memset(a + 1, 0, 4 * n);

    for (int i = 1; i <= m; i++)
        if (b[i].len > x) {
            cnt++, checkmax(lim, b[i].len - x);
            a[b[i].u]++, a[b[i].v]++, a[b[i].lca] -= 2;
        }

    for (int i = n; i >= 1; i--) {
        int u = seq[i];

        if (a[u] == cnt && w[u] >= lim)
            return true;

        a[fa[u]] += a[u];
    }

    return false;
}
int main(int argc, char const *argv[]) {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    Read(n, m);
    std::memset(head + 1, -1, 4 * n);

    for (int i = 1; i < n; i++) {
        int u = Read(), v = Read(), c = Read();
        Add(u, v, c), Add(v, u, c);
    }

    Dfs(1, 0), Dfs2(1, 1);

    for (int i = 1; i <= m; i++) {
        Read(b[i].u, b[i].v);
        b[i].lca = GetLca(b[i].u, b[i].v);
        b[i].len = dis[b[i].u] + dis[b[i].v] - 2 * dis[b[i].lca];
    }

    int l = 0, r = 1000 * n, ans = -1;

    while (l <= r) {
        int mid = (l + r) >> 1;

        if (Check(mid))
            ans = mid, r = mid - 1;
        else
            l = mid + 1;
    }

    std::cout << ans;
    return 0;
}