#include <bits/stdc++.h>

using namespace std;

using ll = int64_t;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;

constexpr int I_INF = INT_MAX;
constexpr ll L_INF = LLONG_MAX;

//===



using Graph = std::vector<std::vector<int>>;


constexpr int64_t MOD = static_cast<int64_t>(1e9 + 7);

template <std::int_fast64_t Modulus>
class ModInt
{
	using i64 = std::int_fast64_t;

public:
	i64 a;

	constexpr ModInt(const i64 x = 0) noexcept : a(x% Modulus) {}

	constexpr i64& value() noexcept { return a; }
	constexpr const i64& value() const noexcept { return a; }

	constexpr ModInt operator+(const ModInt& rhs) const noexcept
	{
		return ModInt(*this) += rhs;
	}
	constexpr ModInt operator-(const ModInt& rhs) const noexcept
	{
		return ModInt(*this) -= rhs;
	}
	constexpr ModInt operator*(const ModInt& rhs) const noexcept
	{
		return ModInt(*this) *= rhs;
	}
	constexpr ModInt operator/(const ModInt& rhs) const noexcept
	{
		return ModInt(*this) /= rhs;
	}

	constexpr ModInt& operator+=(const ModInt rhs) noexcept
	{
		a += rhs.a;
		if (a >= Modulus) {
			a -= Modulus;
		}
		return *this;
	}
	constexpr ModInt& operator-=(const ModInt rhs) noexcept
	{
		if (a < rhs.a) {
			a += Modulus;
		}
		a -= rhs.a;
		return *this;
	}
	constexpr ModInt& operator*=(const ModInt rhs) noexcept
	{
		a = a * rhs.a % Modulus;
		return *this;
	}
	constexpr ModInt& operator/=(ModInt rhs) noexcept
	{
		i64 exp = Modulus - 2;
		while (exp) {
			if (exp & 1) {
				*this *= rhs;
			}
			rhs *= rhs;
			exp >>= 1;
		}
		return *this;
	}

	constexpr ModInt& operator++() noexcept
	{
		*this += 1;
		return *this;
	}
	constexpr ModInt operator++(int) noexcept
	{
		ModInt res = *this;
		*this += 1;
		return res;
	}
	constexpr ModInt& operator--() noexcept
	{
		*this -= 1;
		return *this;
	}
	constexpr ModInt operator--(int) noexcept
	{
		ModInt res = *this;
		*this -= 1;
		return res;
	}

	constexpr bool operator<(const ModInt& rhs) const noexcept
	{
		return a < rhs.a;
	}
	constexpr bool operator>(const ModInt& rhs) const noexcept
	{
		return a > rhs.a;
	}
	constexpr bool operator<=(const ModInt& rhs) const noexcept
	{
		return a <= rhs.a;
	}
	constexpr bool operator>=(const ModInt& rhs) const noexcept
	{
		return a >= rhs.a;
	}
	constexpr bool operator==(const ModInt& rhs) const noexcept
	{
		return a == rhs.a;
	}

	constexpr ModInt pow(i64 k) const noexcept
	{
		ModInt res = 1;
		ModInt tmp = *this;
		for (; k > 0; k >>= 1) {
			if (k & 1) res *= tmp;
			tmp *= tmp;
		}
		return res;
	}

	constexpr ModInt inverse() const noexcept
	{
		i64 q = a;
		i64 b = Modulus, u = 1, v = 0;
		while (b) {
			i64 t = q / b;
			q -= t * b;
			swap(q, b);
			u -= t * v;
			swap(u, v);
		}
		u %= Modulus;
		if (u < 0) u += Modulus;
		return u;
	}
};




int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	int N, K;
	cin >> N >> K;

	Graph g(N);
	for (int i = 0; i < N - 1; ++i) {
		int a, b;
		cin >> a >> b;
		--a; --b;
		g[a].push_back(b);
		g[b].push_back(a);
	}

	ModInt<MOD> ans = 1;

	vector<bool> checked(N);
	queue<tuple<int, int, int, int>> q;
	q.emplace(0, K, 1, 0);
	checked[0] = true;
	while (!q.empty()) {
		int u, c, d, level;
		tie(u, c, d, level) = q.front();
		q.pop();
		ans *= c;

		int b;
		if (level >= 2) b = 1;
		else b = 0;

		int cnt = 1;
		for (const auto& to : g[u]) {
			if (checked[to]) continue;
			q.emplace(to, c + d - 1 + b - cnt, cnt, level + 1);
			checked[to] = true;
			++cnt;
		}
	}


	cout << ans.value() << "\n";


	return 0;
}

Measured memory_bytes: 7800