#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define mem(a,b) memset(a,b,sizeof(a))
#define mpy(a,b) memcpy(a,b,sizeof(b))
#define dbg(...) cerr<<"#"<<__LINE__<<": "<<__VA_ARGS__<<endl
#define Fi(s) freopen(s,"r",stdin)
#define Fo(s) freopen(s,"w",stdout)
#define Fio(s) Fi(s".in"),Fo(s".out")
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template<int P>
class mod_int{
    using Z=mod_int;
private:
    static int mo(int x){return x<0?x+P:x;}
public:
    int x;
    int val()const{return x;}
    mod_int():x(0){}
    template<class T>mod_int(const T&x_):x(x_>=0&&x_<P?static_cast<int>(x_):mo(static_cast<int>(x_%P))){}
    bool operator==(const Z&rhs)const{return x==rhs.x;}
    bool operator!=(const Z&rhs)const{return x!=rhs.x;}
    Z operator-()const{return Z(x?P-x:0);}
    Z pow(long long k)const{Z res=1,t=*this;while(k){if(k&1)res*=t;if(k>>=1)t*=t;}return res;}
    Z&operator++(){x<P-1?++x:x=0;return *this;}
    Z&operator--(){x?--x:x=P-1;return *this;}
    Z operator++(int){Z ret=x;x<P-1?++x:x=0;return ret;}
    Z operator--(int){Z ret=x;x?--x:x=P-1;return ret;}
    Z inv()const{return pow(P-2);}
    Z&operator+=(const Z&rhs){(x+=rhs.x)>=P&&(x-=P);return *this;}
    Z&operator-=(const Z&rhs){(x-=rhs.x)<0&&(x+=P);return *this;}
    Z&operator*=(const Z&rhs){x=1ULL*x*rhs.x%P;return *this;}
    Z&operator/=(const Z&rhs){return *this*=rhs.inv();}
#define setO(T,o) friend T operator o(const Z&lhs,const Z&rhs){Z res=lhs;return res o##=rhs;}
    setO(Z,+)setO(Z,-)setO(Z,*)setO(Z,/)
#undef setO
};
const int P = 998244353;
using Z = mod_int<P>;

ll qpow(ll x, ll k){
    ll ret = 1;
    while(k){
        if(k & 1) (ret *= x) %= mod;
        (x *= x) %= mod, k >>= 1;
    }
    return ret;
}

namespace Poly_space{
    Z inv2 = (P + 1) / 2;
    vector<int> rev;
    vector<Z> gg = {0, 1};
    Z rt = 3;
    void setroot(Z x){rt = x;}
    void dft(vector<Z> &a){
        int n = a.size();
        if((int)rev.size() != n){
            int k = __builtin_ctz(n) - 1; rev.resize(n);
            for(int i = 0; i < n; i++){rev[i] = rev[i >> 1] >> 1 | (i & 1 ? (1 << k) : 0);}
        }
        for(int i = 0; i < n; i++) if(i < rev[i]) swap(a[i], a[rev[i]]);
        if((int)gg.size() < n){
            int k = __builtin_ctz(gg.size()); gg.resize(n);
            while((1 << k) < n){
                Z e = rt.pow((P - 1) >> (k + 1));
                for(int i = (1 << (k - 1)); i < (1 << k); i++) gg[i << 1] = gg[i], gg[(i << 1) | 1] = gg[i] * e;
                k++;
            }
        }
        for(int mid = 1; mid < n; mid <<= 1) for(int i = 0; i < n; i += (mid << 1)) for(int j = 0; j < mid; j++){
            Z x = a[i + j], y = a[i + j + mid] * gg[mid + j];
            a[i + j] = x + y, a[i + j + mid] = x - y;
        }
    }
    void idft(vector<Z> &a){
        int n = a.size(); reverse(a.begin() + 1, a.end()), dft(a);
        Z inv = Z(1 - P) / Z(n); for(int i = 0; i < n; i++) a[i] *= inv;
    }
    struct Poly{
        vector<Z> a;
        Poly(){} Poly(const vector<Z> &x): a(x){} Poly(const initializer_list<Z> &x): a(x){}
        int size()const{return a.size();} void resize(int x){a.resize(x);}
        Z operator [](int ind)const{if(ind < 0 || ind >= size()) return 0; return a[ind];}
        Z&operator [](int ind){return a[ind];}
        Poly modxk(int k)const{k = min(k, size()); return Poly(vector<Z>(a.begin(), a.begin() + k));}
        Poly mulxk(int k)const{vector<Z> b = a; b.insert(b.begin(), k, 0); return b;}
        Poly divxk(int k)const{if(size() <= k) return Poly(); return Poly(vector<Z>(a.begin() + k, a.end()));}
        friend Poly operator + (const Poly &a, const Poly &b){
            vector<Z> ret(max(a.size(), b.size()));
            for(int i = 0; i < ret.size(); i++) ret[i] = a[i] + b[i];
            return Poly(ret);
        }
        friend Poly operator - (const Poly &a, const Poly &b){
            vector<Z> ret(max(a.size(), b.size()));
            for(int i = 0; i < ret.size(); i++) ret[i] = a[i] - b[i];
            return Poly(ret);
        }
        friend Poly operator * (const Poly &a, const Z &b){
            vector<Z> ret(a.size());
            for(int i = 0; i < ret.size(); i++) ret[i] = a[i] * b;
            return Poly(ret);
        }
        friend Poly operator * (Poly a, Poly b){
            if(a.size() == 0 || b.size() == 0) return Poly();
            int sz = 1, n = a.size() + b.size() - 1;
            while(sz < n) sz <<= 1;
            a.resize(sz), b.resize(sz), dft(a.a), dft(b.a);
            for(int i = 0; i < sz; i++) a.a[i] = a[i] * b[i];
            idft(a.a), a.resize(n); return a;
        }
        Poly inv(int deg)const{
            if(deg == 1) return Poly({a[0].pow(P - 2)});
            Poly res = inv((deg + 1) >> 1), tmp = *this;
            int sz = 1; while(sz < (deg << 1)) sz <<= 1;
            tmp = tmp.modxk(deg), tmp.resize(sz), res.resize(sz);
            dft(tmp.a), dft(res.a);
            for(int i = 0; i < sz; i++) res[i] = 2 * res[i] - res[i] * res[i] * tmp[i];
            idft(res.a), res.resize(deg);
            return res;
        }
        Poly derivative()const{
            if(size() == 1) return Poly();
            Poly ret(vector<Z>(size() - 1));
            for(int i = 1; i < size(); i++) ret.a[i - 1] = a[i] * i;
            return ret;
        }
        Poly integrate()const{
            Poly ret(vector<Z>(size() + 1));
            for(int i = 1; i < ret.size(); i++) ret.a[i] = a[i - 1] * Z(i).inv();
            return ret;
        }
        Poly ln(int deg){
            Poly res = derivative(), tmp = inv(deg);
            res = (res * tmp).integrate(), res.resize(deg);
            return res;
        }
        Poly exp(int deg){
            Poly ret(vector<Z>(1)); ret[0] = 1; int i = 1;
            while(i < deg) i <<= 1, ret = (ret * (Poly({1}) - ret.ln(i) + modxk(i))).modxk(i);
            return ret.modxk(deg);
        }
    };
}
using namespace Poly_space;

Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,m;
Z inv[4005],_P[4005],C[4005][4005],fact[4005],ifac[4005];
Z _prd[4005],_iprd[4005];

Z CC(int N,int M){//1 <= M <= n + 1,m - 1 <= N <= m + n + 1
    if(N < 0 || N < M) return 0;
    if(N <= 2 * n + 3) return fact[N] * ifac[M] * ifac[N - M];
    return _prd[N - (m - n - 1)] * _iprd[N - M - (m - n - 1)] * ifac[M];
}

int cnt;
int head[2005];
struct eg{
    int to,nxt;
}edge[4005];

void make(int u,int v){
    edge[++cnt].to = v;
    edge[cnt].nxt = head[u];
    head[u] = cnt;
}

Z dp[2005][2005],tmp[2005],temp[2005],answer;
int siz[2005];
Poly f,g;
void dfs(int u,int fa){
    dp[u][0] = 1;//1/(1-x)
    siz[u] = 1;
    for(int i = head[u];i;i = edge[i].nxt){
        int v = edge[i].to;
        if(v == fa) continue;

        dfs(v,u);
        rep(p,0,siz[u]){
            rep(q,0,siz[v]) tmp[p + q] += dp[u][p] * dp[v][q];
        }
        siz[u] += siz[v];
        rep(p,0,siz[u]){
            dp[u][p] = tmp[p];
            tmp[p] = 0;
        }
    }

    f.a.clear();g.a.clear();
    rep(i,0,siz[u]) f.a.eb(dp[u][i] * _iprd[n - i]);
    rep(i,-siz[u],siz[u]) g.a.eb(_prd[i + n]);        

    f = f * g;
    rep(i,0,siz[u] - 1) tmp[i] = -f.a[i + siz[u]] * ifac[i];
//    rep(i,0,siz[u] - 1) printf("%d ",tmp[i].val());
//    printf("\n");

    f.a.clear();g.a.clear();
    rep(i,0,siz[u]) f.a.eb(tmp[i] * fact[i]);
    rep(i,0,siz[u]) g.a.eb(ifac[i]);
    reverse(g.a.begin(),g.a.end());
    f = f * g;
    rep(i,0,siz[u]) temp[i] = f.a[i + siz[u]] * ifac[i];
    
    rep(i,0,siz[u] - 1) if(i % 2) temp[i] *= -1;

    Z ways = _P[siz[u]];
    rep(i,0,siz[u]) ways -= CC(m - i + siz[u] - 1,siz[u]) * dp[u][i];// >= m 的方案数
    reverse(dp[u],dp[u] + siz[u] + 1);reverse(temp,temp + siz[u] + 1);
    rep(i,0,siz[u]) swap(dp[u][i],temp[i]);
    if(siz[u] % 2) rep(i,0,siz[u]) dp[u][i] *= -1;

    Z prd = 1;
    rep(i,0,siz[u]){
        if(i % 2) dp[u][i] -= ways * prd;
        else dp[u][i] += ways * prd;
        prd *= (siz[u] - i) * inv[i + 1];
    }
    fill(tmp,tmp + siz[u] + 1,0);
    fill(temp,temp + siz[u] + 1,0);

    Z res = _P[siz[u]] * (m + 1);
    rep(i,0,siz[u]) res -= CC(m - i + siz[u] + 1,siz[u] + 1) * dp[u][i];
    answer += res * _P[n - siz[u]];
}   

void dfs2(int u,int fa){
    dp[u][0] = 1;
    siz[u] = 1;
    for(int i = head[u];i;i = edge[i].nxt){
        int v = edge[i].to;
        if(v == fa) continue;
        dfs2(v,u);
        siz[u] += siz[v];
        f.a.clear();g.a.clear();
        rep(p,0,m){
            f.a.eb(dp[u][p]);
            g.a.eb(dp[v][p]);
        }
        f = f * g;
        fill(dp[u],dp[u] + m + 1,0);
        rep(p,0,2 * m) dp[u][min(p,m)] += f.a[p];
    }
    Z awa = 0;
    rep(i,0,m) awa += dp[u][i] * i;
    reverse(dp[u],dp[u] + m + 1);
    per(i,m,1) dp[u][i] += dp[u][i + 1];
    dp[u][0] = awa;

    awa = 0;
    rep(i,0,m) awa += dp[u][i] * i;
    answer += awa * _P[n - siz[u]];
}

void prepare(int L){
    _P[0] = 1;
    rep(i,1,L) _P[i] = _P[i - 1] * m;
    rep(i,0,L){
        C[i][0] = 1;
        rep(j,1,i) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
    }    
    fact[0] = 1;
    rep(i,1,L) fact[i] = fact[i - 1] * i;
    ifac[L] = Z(1) / fact[L];
    per(i,L - 1,0) ifac[i] = ifac[i + 1] * (i + 1);
    rep(i,1,L) inv[i] = ifac[i] * fact[i - 1];
}

int main(){
//    freopen("test.in","r",stdin);
    scanf("%d%d",&n,&m);
    prepare(2 * n + 3);
    rep(i,1,n - 1){
        int u,v;
        scanf("%d%d",&u,&v);
        make(u,v);make(v,u);
    }
    _prd[0] = _iprd[0] = 1;
    rep(i,1,2 * n + 2){
        _prd[i] = _prd[i - 1] * (m - n - 1 + i);
        _iprd[i] = _iprd[i - 1] / (m - n - 1 + i);
    }
    if(m <= n + 1) dfs2(1,0);
    else dfs(1,0);
    printf("%d\n",answer.val());
	return 0;
}