Thank you for helping Heidi! It is now the second of April, but she has been summoned by Jenny again. The pranks do not seem to end...

In the meantime, Heidi has decided that she does not trust her friends anymore. Not too much, anyway. Her relative lack of trust is manifested as follows: whereas previously she would not be made to visit the same person twice, now she can only be sure that she will not be made to visit the same person more than k times. (In the case of Jenny, this includes her first visit in the beginning. The situation from the easy version corresponds to setting k = 1.)

This is not as bad as it looks, since a single ticket for a route between two friends allows Heidi to travel between this pair of friends the whole day (in both directions). In other words, once she pays for travel between a pair of friends, all further travels between that pair are free.

How much money will Heidi waste now, in a worst-case scenario?

Input

The first line contains two space-separated integers – the number of friends n (<image>) and the parameter k (1 ≤ k ≤ 105). The next n - 1 lines each contain three space-separated integers u, v and c (0 ≤ u, v ≤ n - 1, 1 ≤ c ≤ 104) meaning that u and v are friends and the cost for traveling between u and v is c.

It is again guaranteed that the social network of the input forms a tree.

Output

Again, output a single integer – the maximum sum of costs of tickets.

Examples

Input

9 3
0 1 1
0 2 1
1 3 2
1 4 2
1 5 2
2 6 3
2 7 3
2 8 3


Output

15


Input

9 5
0 1 1
0 2 1
1 3 2
1 4 2
1 5 2
2 6 3
2 7 3
2 8 3


Output

17


Input

11 6
1 0 7932
2 1 1952
3 2 2227
4 0 9112
5 4 6067
6 0 6786
7 6 3883
8 4 7137
9 1 2796
10 5 6200


Output

54092

Note

In the first example, the worst-case scenario for Heidi is to visit the friends in the following order: 0, 1, 5, 1, 3, 1, 0, 2, 6, 2, 7, 2, 8. Observe that no friend is visited more than 3 times.
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int> > adj[100100];
long long dp[100100][2];
void dfs(int x, int p) {
  set<pair<long long, int> > cur;
  for (auto i : adj[x]) {
    if (i.first != p) {
      dfs(i.first, x);
      cur.insert(make_pair(-dp[i.first][0] - i.second, i.first));
    }
  }
  int cnt = 0;
  long long s = 0;
  int e = 0;
  set<int> inc;
  for (auto i : cur) {
    cnt++;
    s += -i.first;
    inc.insert(i.second);
    if (cnt == k) {
      e = -i.first;
      break;
    }
  }
  dp[x][0] = s - e;
  dp[x][1] = 0;
  for (auto i : adj[x]) {
    if (i.first != p) {
      if (inc.find(i.first) == inc.end()) {
        dp[x][1] = max(dp[x][1], s - e + dp[i.first][1] + i.second);
      } else {
        dp[x][1] = max(dp[x][1], s - dp[i.first][0] + dp[i.first][1]);
      }
    }
  }
}
int main() {
  cin >> n >> k;
  int ai, bi, ci;
  for (int i = 0; i < n - 1; i++) {
    cin >> ai >> bi >> ci;
    adj[ai].push_back(make_pair(bi, ci));
    adj[bi].push_back(make_pair(ai, ci));
  }
  dfs(0, 0);
  cout << max(dp[0][0], dp[0][1]) << endl;
}
