package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

const MOD int64 = 1000000007

var fact []int64
var invFact []int64

func power(base, exp int64) int64 {
	var res int64 = 1
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = res * base % MOD
		}
		base = base * base % MOD
		exp /= 2
	}
	return res
}

func nCr(n, r int) int64 {
	if r < 0 || r > n {
		return 0
	}
	return fact[n] * invFact[r] % MOD * invFact[n-r] % MOD
}

func mul(A, B []int64, k int) []int64 {
	degA := len(A) - 1
	degB := len(B) - 1
	degC := degA + degB
	if degC > k {
		degC = k
	}
	C := make([]int64, degC+1)
	for i := 0; i <= degA; i++ {
		if A[i] == 0 {
			continue
		}
		for j := 0; j <= degB; j++ {
			if i+j <= k {
				C[i+j] = (C[i+j] + A[i]*B[j]) % MOD
			}
		}
	}
	return C
}

func add(A, B []int64) []int64 {
	degA := len(A) - 1
	degB := len(B) - 1
	degC := degA
	if degB > degC {
		degC = degB
	}
	C := make([]int64, degC+1)
	for i := 0; i <= degC; i++ {
		if i <= degA {
			C[i] += A[i]
		}
		if i <= degB {
			C[i] += B[i]
		}
		C[i] %= MOD
	}
	return C
}

func getShiftedBinom(m, k int) []int64 {
	deg := m + 1
	if deg > k {
		deg = k
	}
	res := make([]int64, deg+1)
	for j := 0; j <= k-1 && j <= m; j++ {
		res[j+1] = nCr(m, j)
	}
	return res
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024)
	scanner.Split(bufio.ScanWords)

	scanInt := func() int {
		scanner.Scan()
		res, _ := strconv.Atoi(scanner.Text())
		return res
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	k := scanInt()

	adj := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		u := scanInt()
		v := scanInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	maxVal := n
	if k > n {
		maxVal = k
	}
	fact = make([]int64, maxVal+1)
	invFact = make([]int64, maxVal+1)
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= maxVal; i++ {
		fact[i] = fact[i-1] * int64(i) % MOD
	}
	invFact[maxVal] = power(fact[maxVal], MOD-2)
	for i := maxVal - 1; i >= 1; i-- {
		invFact[i] = invFact[i+1] * int64(i+1) % MOD
	}

	P := make([][]int64, n+1)
	size := make([]int, n+1)

	var dfs func(u, p int)
	dfs = func(u, p int) {
		size[u] = 1
		P[u] = []int64{2}
		for _, v := range adj[u] {
			if v == p {
				continue
			}
			dfs(v, u)
			size[u] += size[v]

			term := add(getShiftedBinom(size[v]-1, k), P[v])
			P[u] = mul(P[u], term, k)
		}
	}
	dfs(1, 0)

	R := make([]int64, len(P[1]))
	copy(R, P[1])

	for i := 2; i <= n; i++ {
		term1 := P[i]
		m := n - size[i] - 1
		term2 := getShiftedBinom(m, k)
		prod := mul(term1, term2, k)
		R = add(R, prod)
	}

	if len(R) < k+1 {
		newR := make([]int64, k+1)
		copy(newR, R)
		R = newR
	}

	V := make([]int64, k+1)
	for j := 0; j <= k; j++ {
		T_j := R[j]
		sub := nCr(n-1, j) * int64(j+1) % MOD
		V[j] = (T_j - sub + MOD) % MOD
	}

	c := make([]int64, k+1)
	for j := 0; j <= k; j++ {
		var sum int64 = 0
		for i := 0; i <= j; i++ {
			val := int64(n - 1 - i)
			val = (val%MOD + MOD) % MOD
			term := nCr(j, i) * power(val, int64(k)) % MOD
			if (j-i)%2 == 1 {
				sum = (sum - term + MOD) % MOD
			} else {
				sum = (sum + term) % MOD
			}
		}
		c[j] = sum
	}

	var ans int64 = 0
	for j := 0; j <= k; j++ {
		ans = (ans + c[j]*V[j]) % MOD
	}

	fmt.Println(ans)
}