from collections import deque
while True:
    line = input()
    if not line:
        break
    n, q = map(int, line.split())
    c = [[] for _ in range(n)]
    tot = 0
    for i in range(n - 1):
        u, v, w = map(int, input().split())
        u -= 1
        v -= 1
        c[u].append((v, w))
        c[v].append((u, w))
        tot += w

    depth = [0] * n
    longest = [[] for _ in range(n)]
    def doLongest(x, prev, dp):
        depth[x] = dp
        ret = 0
        for y, d in c[x]:
            if y == prev:
                longest[x].append((-1, y))
            else:
                longest[x].append((d + doLongest(y, x, dp + 1), y))
                ret = max(ret, longest[x][-1][0])
        return ret
    doLongest(0, -1, 0)
    def getLongest(x, ex1, ex2):
        for l, y in longest[x]:
            if y != ex1 and y != ex2:
                return l
        return 0
    def doParLongest(x, prev, parLongest):
        for i in range(len(longest[x])):
            l, _ = longest[x][i]
            if l == -1:
                longest[x][i] = (parLongest, longest[x][i][1])
        longest[x].sort(reverse=True)
        for y, d in c[x]:
            if y != prev:
                doParLongest(y, x, d + getLongest(x, y, -1))
    doParLongest(0, -1, 0)

    skipNd = [[] for _ in range(n)]
    skipPrev = [[] for _ in range(n)]
    skipSUp = [[] for _ in range(n)]
    skipSDn = [[] for _ in range(n)]
    skipKUp = [[] for _ in range(n)]
    skipKDn = [[] for _ in range(n)]
    for i in range(n):
        skipNd[i].append(i)
        skipPrev[i].append(-1)
        skipSUp[i].append(0)
        skipSDn[i].append(0)
        skipKUp[i].append(0)
        skipKDn[i].append(0)
    for i in range(n):
        for j in range(1, n):
            if i - j >= 0:
                skipNd[i].append(skipNd[skipPrev[i][j - 1]][j - 1])
                skipPrev[i].append(skipPrev[skipPrev[i][j - 1]][j - 1])
                skipSUp[i].append(max(skipSUp[i][-1], skipSUp[skipPrev[i][j - 1]][j - 1] + getLongest(skipNd[i][-1], skipNd[skipPrev[i][j - 1]][j - 1], i)))
                skipSDn[i].append(max(skipSDn[i][-1], skipSDn[skipPrev[i][j - 1]][j - 1] + getLongest(skipNd[skipNd[i][-1]][-1], skipNd[skipNd[skipPrev[i][j - 1]][j - 1]][-1], skipNd[i][-1])))
                skipKUp[i].append(max(skipKUp[i][-1], skipKUp[skipPrev[i][j - 1]][j - 1] - getLongest(skipNd[i][-1], skipNd[skipPrev[i][j - 1]][j - 1], i)))
                skipKDn[i].append(max(skipKDn[i][-1], skipKDn[skipPrev[i][j - 1]][j - 1] - getLongest(skipNd[skipNd[i][-1]][-1], skipNd[skipNd[skipPrev[i][j - 1]][j - 1]][-1], skipNd[i][-1])))
            else:
                skipNd[i].append(-1)
                skipPrev