#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

#ifdef LBT
mt19937_64 rng(20030811);
#else
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#endif

template <class T>
istream& operator>>(istream& is, vector<T>& v) {
  for (T& x : v)
    is >> x;
  return is;
}

template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int N = 25010, L = 20, Djq = 1000000007;

int norm(int x) { return x >= Djq ? x - Djq : x; }

int Base;

struct Node {
  Node *ls, *rs;
  int hsh;
};

int n;
Node pool[N * L * L], *top = pool;
int pwBase[N], tmp[N];

Node* build(int l, int r) {
  Node* o = top++;
  if (l == r) {
    o->hsh = tmp[l];
    return o;
  }
  int mid = (l + r) >> 1;
  o->ls = build(l, mid);
  o->rs = build(mid + 1, r);
  o->hsh = (o->ls->hsh * (ll)pwBase[r - mid] + o->rs->hsh) % Djq;
  return o;
}

Node* change(const Node* p, int l, int r, int k, int v) {
  Node* o = top++;
  if (l == r)
    o->hsh = p->hsh + v;
  else {
    int mid = (l + r) >> 1;
    o->ls = k <= mid ? change(p->ls, l, mid, k, v) : p->ls;
    o->rs = k > mid ? change(p->rs, mid + 1, r, k, v) : p->rs;
    o->hsh = (o->ls->hsh * (ll)pwBase[r - mid] + o->rs->hsh) % Djq;
  }
  return o;
}

// suppose x->hsh != y->hsh
int cmp(const Node* x, const Node* y, int l, int r) {
  if (l == r) return x->hsh < y->hsh ? -1 : 1;
  int mid = (l + r) >> 1;
  return x->rs->hsh == y->rs->hsh ? cmp(x->ls, y->ls, l, mid) : cmp(x->rs, y->rs, mid + 1, r);
}

int sumcmp(const Node* x, const Node* y, const Node* z, int l, int r) {
  if (norm(x->hsh + y->hsh) == z->hsh) return 0;
  if (l == r)
    return (x->hsh + y->hsh) < z->hsh ? -1 : 1;
  int mid = (l + r) >> 1;
  int o = sumcmp(x->rs, y->rs, z->rs, mid + 1, r);
  return o ? o : sumcmp(x->ls, y->ls, z->ls, l, mid);
}

void getv(const Node* o, int l, int r) {
  if (l == r) {
    tmp[l] += o->hsh;
    return;
  }
  int mid = (l + r) >> 1;
  getv(o->ls, l, mid);
  getv(o->rs, mid + 1, r);
}

struct PInt {
  Node* rt;

  PInt() {}

  PInt(Node *rt) : rt(rt) {}

  int getDigit(int k) const {
    int l = 1, r = n;
    const Node* o = rt;
    while (l != r) {
      int mid = (l + r) >> 1;
      if (k <= mid) {
        r = mid;
        o = o->ls;
      } else {
        l = mid + 1;
        o = o->rs;
      }
    }
    return o->hsh;
  }

  PInt change(int k, int x) const {
    return PInt(::change(rt, 1, n, k, x));
  }

  bool operator<(const PInt& rhs) const {
    if (rt->hsh == rhs.rt->hsh) return false;
    return cmp(rt, rhs.rt, 1, n) < 0;
  }

  bool operator==(const PInt& rhs) const {
    return rt->hsh == rhs.rt->hsh;
  }
};

// cmp(x + y, z)
int sumcmp(const PInt& x, const PInt& y, const PInt& z) { return sumcmp(x.rt, y.rt, z.rt, 1, n); }

PInt PZero, PInf;

vector<pair<int, int>> g[N];
vector<PInt> mL[N * 2], mR[N * 2];
vector<pair<int, int>> range[N * 2];

int curSz;
bool vis[N];
int sz[N];

int main() {
#ifdef LBT
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  ll k;
  cin >> n >> k;
  for (int rep = 1; rep < n; ++rep) {
    int u, v, w;
    cin >> u >> v >> w;
    g[u].emplace_back(v, w);
    g[v].emplace_back(u, w);
  }

  Base = rng() % (Djq - n * 4) + n * 2;
  pwBase[0] = 1;
  for (int i = 1; i <= n; ++i) pwBase[i] = pwBase[i - 1] * (ll)Base % Djq;

  PZero = PInt(build(1, n));
  fill(tmp + 1, tmp + n + 1, n);
  PInf = PInt(build(1, n));

  function<void(int, int)> dfs = [&](int u, int p) {
    sz[u] = 1;
    for (auto [v, ignore] : g[u])
      if (v != p && !vis[v]) {
        dfs(v, u);
        sz[u] += sz[v];
      }
    if (p == -1) curSz = sz[u];
  };
  function<int(int, int)> centroid = [&](int u, int p) {
    for (auto [v, ignore] : g[u])
      if (v != p && !vis[v] && (sz[v] << 1) > curSz)
        return centroid(v, u);
    return u;
  };
  vector<PInt> cur;
  function<void(int, int, const PInt&)> dfs2 = [&](int u, int p, const PInt& dis) {
    cur.push_back(dis);
    for (auto [v, w] : g[u])
      if (!vis[v] && v != p)
        dfs2(v, u, dis.change(w, 1));
  };
  priority_queue<vector<PInt>, vector<vector<PInt>>, function<bool(const vector<PInt> &, const vector<PInt> &)>> q(
          [&](const vector<PInt> &lhs, const vector<PInt> &rhs) { return lhs.size() > rhs.size(); });
  int m = 0;
  function<void(int)> solve = [&](int u) {
    dfs(u, -1);
    u = centroid(u, -1);
    vis[u] = true;
    q.push({PZero});
    for (auto [v, w] : g[u])
      if (!vis[v]) {
        dfs2(v, u, PZero.change(w, 1));
        stable_sort(cur.begin(), cur.end());
        q.push(cur);
        cur.clear();
      }
    while (q.size() > 1) {
      vector<PInt> vL = q.top(); q.pop();
      vector<PInt> vR = q.top(); q.pop();
      mL[++m] = vL;
      mR[m] = vR;
      range[m].resize(vL.size());
      vector<PInt> mg;
      mg.reserve(vL.size() + vR.size());
      merge(vL.begin(), vL.end(), vR.begin(), vR.end(), back_inserter(mg));
      q.push(mg);
    }
    q.pop();
    for (auto [v, ignore] : g[u])
      if (!vis[v])
        solve(v);
  };
  solve(1);

  PInt low = PZero, high = PInf;
  ll lowC = 0, highC = n * (n - 1LL) / 2 + 1;

  ll to = 0;
  for (int i = 1; i <= m; ++i) {
    to += mL[i].size() * mR[i].size();
  }

  while (lowC < k && k < highC) {
    uniform_int_distribution<ll> uid(0, highC - lowC - 2);
    ll kth = uid(rng);
    PInt pivot;
    for (int i = 1; i <= m; ++i) {
      int pL = 0, pR = 0;
      for (int j = (int)mL[i].size() - 1; j >= 0; --j) {
        while (pL != mR[i].size() && sumcmp(mL[i][j], mR[i][pL], low) <= 0) ++pL;
        while (pR != mR[i].size() && sumcmp(mL[i][j], mR[i][pR], high) < 0) ++pR;
        range[i][j] = make_pair(pL, pR);
      }
    }
    for (int i = 1; i <= m; ++i) {
      for (int j = (int)mL[i].size() - 1; j >= 0; --j) {
        int len = range[i][j].second - range[i][j].first;
        if (len > kth) {
          memset(tmp, 0, sizeof(tmp));
          getv(mL[i][j].rt, 1, n);
          getv(mR[i][range[i][j].first + kth].rt, 1, n);
          pivot = build(1, n);
          kth = -1; break;
        }
        kth -= len;
      }
      if (kth < 0) break;
    }
    ll rL = 1, rR = 0;
    for (int i = 1; i <= m; ++i) {
      int pL = 0, pR = 0;
      for (int j = (int)mL[i].size() - 1; j >= 0; --j) {
        while (pL != mR[i].size() && sumcmp(mL[i][j], mR[i][pL], pivot) < 0) ++pL;
        while (pR != mR[i].size() && sumcmp(mL[i][j], mR[i][pR], pivot) <= 0) ++pR;
        rL += pL;
        rR += pR;
      }
    }
    if (rL > k) {
      high = pivot;
      highC = rL;
    } else {
      low = pivot;
      lowC = rR;
    }
  }
  memset(tmp, 0, sizeof(tmp));
  getv(k <= lowC ? low.rt : high.rt, 1, n);
  int ans = 0;
  for (int i = n; i >= 0; --i) ans = (ans * (ll)n + tmp[i]) % Djq;
  cout << ans << '\n';

#ifdef LBT
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}