//Generated at 2019-07-07 22:08:34 UTC+8
//Created by Alphagocc
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
//C11
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
// C++11
#include <array>
#include <atomic>
#include <chrono>
#include <codecvt>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
// namespace IO 
namespace IO
{
template <typename T>
void __RI(T &x)
{
    int ch = getchar(), neg = 1;
    x = 0;
    for (; !(isdigit(ch) || ch == '-' || ch == EOF); ch = getchar())
        ;
    if (ch == EOF) return;
    if (ch == '-') neg = -1;
    for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    x *= neg;
}
void R(int &x) { __RI(x); }
void R(int64_t &x) { __RI(x); }
template <typename T1, typename T2>
void R(std::pair<T1, T2> &x)
{
    R(x.first);
    R(x.second);
}
template <typename T>
void R(std::vector<T> &x)
{
    for (auto &i : x) { R(i); }
}
template <typename T>
void R(T &x)
{
    std::cin >> x;
}
template <typename T, typename... Args>
void R(T &x, Args &... args)
{
    R(x), R(args...);
}
char space = ' ';
template <typename T>
void __WI(T x)
{
    if (x == 0) putchar('0');
    if (x < 0) putchar('-'), x = -x;
    char ch[ 64 ];
    int  pos = 0;
    while (x) ch[ pos++ ] = x % 10 + 48, x /= 10;
    while (pos) putchar(ch[ --pos ]);
}
void W() {}
void W(const int &x) { __WI(x); }
void W(const int64_t &x) { __WI(x); }
void W(const double &x) { printf("%lf",static_cast<double>(x)); }
void W(const char &x) { putchar(x); }
void W(const std::string &x) { printf("%s", x.c_str()); }
template <typename T1, typename T2>
void W(const std::pair<T1, T2> &x)
{
    W(x.first);
    W(space);
    W(x.second);
}
template <typename T>
void W(const std::vector<T> &x)
{
    for (auto it = x.cbegin();it != x.cend(); it++)
    {
        W(*it);
        W(space);
    }
    W('\n');
}
template <typename T>
void W(const T &x)
{
    std::cout << x;
}
template <typename T, typename... Args>
void W(const T &x,const Args &... args)
{
    W(x), W(space), W(args...);
}
template <typename... Args>
void WL(const Args &... args)
{
    W(args...), W('\n');
}
}; // namespace IO

using namespace std;

#define REP(i, x, y) for (int i = x;i < y; i++)

const int8_t  INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF  = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
const int   MAXN = 2e5;
const int   MOD  = 1e9 + 7;
vector<int> G[ MAXN ], nG[ MAXN ];

int k, par[ MAXN ], vis[ MAXN ], ans = 1, usedN[ MAXN ];

void calc(int u)
{
    int res = k;
    if (par[ u ] != -1)
    {
        res--;
        if (par[ par[ u ] ] != -1) { res--; }
        res -= usedN[ par[ u ] ]++;
    }
    ans       = 1LL * ans * res % MOD;
}
void bfs(int root)
{
    queue<int> q;
    while (!q.empty()) q.pop();
    q.push(root);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        calc(u);
        for (int i = 0; i < G[ u ].size(); i++)
        {
            int v = G[ u ][ i ];
            q.push(v);
        }
    }
}
void dfs(int x, int p)
{
    for (int i = 0; i < G[ x ].size(); i++)
    {

        if (p != G[ x ][ i ])
            nG[ x ].push_back(G[ x ][ i ]), dfs(G[ x ][ i ], par[ G[ x ][ i ] ] = x);
    }
}
int main()
{
    int n;
    IO::R(n, k);
    memset(par, -1, sizeof(par));
    REP(i, 0, n - 1)
    {
        int x, y;
        IO::R(x, y);
        --x, --y;
        G[ x ].push_back(y);
        G[ y ].push_back(x);
    }
    int root = -1;
    for (int i = 0; i < n && root == -1; i++)
    {
        if (par[ i ] == -1) root = i;
    }
    dfs(0, par[ 0 ] = -1);
    for (int i = 0; i < n; i++) G[ i ] = nG[ i ];
    bfs(0);
    IO::WL(ans);
    return 0;
}

Measured memory_bytes: 22912