#include <fstream>
#include <vector>

using namespace std;

#define PB push_back

typedef long long lint;

const int MOD = 1000000007;
const int NMAX = 100007;

int N, K, result = 1, M;
vector <int> G[NMAX];
int C[NMAX], C1[NMAX], P[NMAX];

void read(void) {
	ifstream fin("colorare3.in");
	int i, a, b;

	fin >> N >> K;

	for (i = 1; i < N; ++i) {
		fin >> a >> b;
		G[a].PB(b);
		G[b].PB(a);
	}

	fin.close();
}

int inversModular(int x) {
	int p, r;

	for (r = 1, p = MOD - 2; p; p >>= 1, x = (lint) x * x % MOD)
		if (p & 1)
			r = (lint) r * x % MOD;

	return r;
}

void DFS(int k, int t) {
	if (k == 1) {
		result = (lint) result * C1[ G[k].size() ] % MOD * P[ G[k].size() ] % MOD;
	} else {
		result = (lint) result * C[ G[k].size() - 1 ] % MOD * P[ G[k].size() - 1 ] % MOD;
	}

	int i;

	for (i = 0; i < (int) G[k].size(); ++i)
		if (G[k][i] != t)
			DFS(G[k][i], k);
}

void solve(void) {
	int i;

	for (i = 1; i <= N; ++i)
		M = max(M, (int) G[i].size());

	C[0] = C1[0] = P[0] = 1;
	for	(i = 1; i <= M; ++i) {
		C[i] = (lint) C[i-1] * (K - i) % MOD * inversModular(i) % MOD;
		C1[i] = (lint) C1[i-1] * (K - i + 1) % MOD * inversModular(i) % MOD;
		P[i] = (lint) P[i-1] * i % MOD;
	}

	DFS(1, 0);
}

void write(void) {
	ofstream fout("colorare3.out");

	fout << result << '\n';

	fout.close();
}

int main(void) {

	read();

	solve();

	write();

	return 0;
}