For problem statement at 0-999/800-899/800-809/802/problemK.txt this is a correct solution, but verifier at 0-999/800-899/800-809/802/verifierK.go ends with All 102 tests passed. can you fix the verifier?  ```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Edge struct {
	to   int
	cost int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, k int
	fmt.Fscan(reader, &n, &k)
	
	adj := make([][]Edge, n)
	for i := 0; i < n-1; i++ {
		var u, v, c int
		fmt.Fscan(reader, &u, &v, &c)
		adj[u] = append(adj[u], Edge{v, c})
		adj[v] = append(adj[v], Edge{u, c})
	}
	
	parent := make([]int, n)
	for i := range parent {
		parent[i] = -1
	}
	order := make([]int, 0, n)
	
	stack := []int{0}
	parent[0] = -2
	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		for _, e := range adj[u] {
			if parent[e.to] == -1 {
				parent[e.to] = u
				stack = append(stack, e.to)
			}
		}
	}
	
	dpF := make([]int64, n)
	dpG := make([]int64, n)
	
	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		var vals []int64
		var childEdges []Edge
		
		for _, e := range adj[u] {
			if e.to != parent[u] {
				childEdges = append(childEdges, e)
				vals = append(vals, int64(e.cost)+dpF[e.to])
			}
		}
		
		sort.Slice(vals, func(i, j int) bool { return vals[i] > vals[j] })
		
		prefix := make([]int64, len(vals)+1)
		for i, v := range vals {
			prefix[i+1] = prefix[i] + v
		}
		
		limitF := k - 1
		if limitF > len(vals) {
			limitF = len(vals)
		}
		if limitF < 0 {
			limitF = 0
		}
		dpF[u] = prefix[limitF]
		
		limitG := k - 1
		if limitG > len(vals) {
			limitG = len(vals)
		}
		if limitG < 0 {
			limitG = 0
		}
		opt1 := prefix[limitG]
		opt2 := int64(0)
		
		topK := min(k, len(vals))
		topKMinus1 := min(k-1, len(vals))
		topKSum := prefix[topK]
		topKMinus1Sum := prefix[topKMinus1]
		var threshold int64 = -1
		if k-1 >= 0 && k-1 < len(vals) {
			threshold = vals[k-1]
		}
		
		for _, e := range childEdges {
			v := e.to
			rv := int64(e.cost) + dpF[v]
			endVal := int64(e.cost) + dpG[v]
			
			var sumOthers int64
			if len(vals) <= k {
				sumOthers = prefix[len(vals)] - rv
			} else {
				if rv > threshold {
					sumOthers = topKSum - rv
				} else {
					sumOthers = topKMinus1Sum
				}
			}
			
			current := endVal + sumOthers
			if current > opt2 {
				opt2 = current
			}
		}
		
		if opt2 > opt1 {
			dpG[u] = opt2
		} else {
			dpG[u] = opt1
		}
	}
	
	fmt.Println(dpG[0])
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
```