import std.conv, std.functional, std.range, std.stdio, std.string; import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons; import core.bitop; class EOFException : Throwable { this() { super("EOF"); } } string[] tokens; string readToken() { for (; tokens.empty; ) { if (stdin.eof) { throw new EOFException; } tokens = readln.split; } auto token = tokens.front; tokens.popFront; return token; } int readInt() { return readToken.to!int; } long readLong() { return readToken.to!long; } real readReal() { return readToken.to!real; } bool chmin(T)(ref T t, in T f) { if (t > f) { t = f; return true; } else { return false; } } bool chmax(T)(ref T t, in T f) { if (t < f) { t = f; return true; } else { return false; } } int binarySearch(alias pred, T)(in T[] as) { int lo = -1, hi = cast(int)(as.length); for (; lo + 1 < hi; ) { const mid = (lo + hi) >> 1; (unaryFun!pred(as[mid]) ? hi : lo) = mid; } return hi; } int lowerBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a >= val)); } int upperBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a > val)); } struct ModInt(int M_) { import std.conv : to; alias M = M_; int x; this(ModInt a) { x = a.x; } this(long a) { x = cast(int)(a % M); if (x < 0) x += M; } ref ModInt opAssign(long a) { return (this = ModInt(a)); } ref ModInt opOpAssign(string op)(ModInt a) { static if (op == "+") { x += a.x; if (x >= M) x -= M; } else static if (op == "-") { x -= a.x; if (x < 0) x += M; } else static if (op == "*") { x = cast(int)((cast(long)(x) * a.x) % M); } else static if (op == "/") { this *= a.inv(); } else static assert(false); return this; } ref ModInt opOpAssign(string op)(long a) { static if (op == "^^") { if (a < 0) return (this = inv()^^(-a)); ModInt t2 = this, te = ModInt(1); for (long e = a; e > 0; e >>= 1) { if (e & 1) te *= t2; t2 *= t2; } x = cast(int)(te.x); return this; } else return mixin("this " ~ op ~ "= ModInt(a)"); } ModInt inv() const { int a = x, b = M, y = 1, z = 0, t; for (; ; ) { t = a / b; a -= t * b; if (a == 0) { assert(b == 1 || b == -1); return ModInt(b * z); } y -= t * z; t = b / a; b -= t * a; if (b == 0) { assert(a == 1 || a == -1); return ModInt(a * y); } z -= t * y; } } ModInt opUnary(string op: "-")() const { return ModInt(-x); } ModInt opBinary(string op, T)(T a) const { return mixin("ModInt(this) " ~ op ~ "= a"); } ModInt opBinaryRight(string op)(long a) const { return mixin("ModInt(a) " ~ op ~ "= this"); } bool opCast(T: bool)() const { return (x != 0); } string toString() const { return x.to!string; } } enum MO = 10^^9 + 7; alias Mint = ModInt!MO; int N, K; int[] A, B; Mint[] mul(Mint[] fs, Mint[] gs) { auto hs = new Mint[K]; foreach (k; 0 .. K) { hs[k] = fs[k] * gs[k]; } return hs; } Mint[] up(Mint[] fs) { auto gs = fs.dup; foreach (k; 1 .. K) { gs[k] += gs[k - 1]; } return gs; } Mint[] shift(Mint[] fs) { return [Mint(0)] ~ fs[0 .. K - 1]; } int[][] G; int[] par; Mint[][] dp, DP; void dfs(int u, int p) { par[u] = p; foreach (i; G[u]) { const v = A[i] ^ B[i] ^ u; if (v != p) { dfs(v, u); } } Mint[] fs = new Mint[K]; fs[] = Mint(1); foreach (i; G[u]) { const v = A[i] ^ B[i] ^ u; if (v != p) { fs = mul(fs, dp[v]); } } dp[u] = up(fs); } void DFS(int u, int p) { int[] vs; foreach (i; G[u]) { const v = A[i] ^ B[i] ^ u; if (v != p) { vs ~= v; } } const len = cast(int)(vs.length); auto ls = new Mint[][len + 1]; auto rs = new Mint[][len + 1]; ls[0] = new Mint[K]; ls[0][] = Mint(1); rs[len] = new Mint[K]; rs[len][] = Mint(1); if (p != -1) { rs[len] = DP[u]; } foreach (j; 0 .. len) { ls[j + 1] = mul(ls[j], dp[vs[j]]); } foreach_reverse (j; 0 .. len) { rs[j] = mul(dp[vs[j]], rs[j + 1]); } foreach (j; 0 .. len) { DP[vs[j]] = up(mul(ls[j], rs[j + 1])); } foreach (j; 0 .. len) { DFS(vs[j], u); } } void main() { try { for (; ; ) { N = readInt(); K = readInt(); A = new int[N - 1]; B = new int[N - 1]; foreach (i; 0 .. N - 1) { A[i] = readInt() - 1; B[i] = readInt() - 1; } G = new int[][N]; foreach (i; 0 .. N - 1) { G[A[i]] ~= i; G[B[i]] ~= i; } par = new int[N]; dp = new Mint[][N]; DP = new Mint[][N]; const rt = 0; dfs(rt, -1); DFS(rt, -1); debug { writeln("rt = ", rt); writeln("dp = ", dp); writeln("DP = ", DP); } Mint ans; foreach (u; 0 .. N) { Mint[] fs = new Mint[K]; fs[] = Mint(1); if (u != rt) { fs = (par[u] < u) ? shift(DP[u]) : DP[u]; } foreach (i; G[u]) { const v = A[i] ^ B[i] ^ u; if (v != par[u]) { fs = mul(fs, (v < u) ? shift(dp[v]) : dp[v]); } } debug { writeln(u, ": ", fs); } ans += fs.sum; } writeln(ans); break; } } catch (EOFException e) { } }