#include <bits/stdc++.h>

using ll = long long;

using namespace std;

const int mod = 998244353, K = 23, Root = 31;
int norm(int x) { return x >= mod ? x - mod : x; }
int reduce(int x) { return x < 0 ? x + mod : x; }
int neg(int x) { return x ? mod - x : 0; }
int quo2(int x) { return (x + (x & 1 ? mod : 0)) >> 1; }
void add(int &x, int y) { x += y, x = x >= mod ? x - mod : x; }
void sub(int &x, int y) { x -= y, x = x < 0 ? x + mod : x; }
void fam(int &x, int y, int z) { x = (x + (ll)y * z) % mod; }
int mpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1) {
    if (b & 1) ret = (ll)ret * a % mod;
    a = (ll)a * a % mod;
  }
  return ret;
}

const int BRUTE_N2_LIMIT = 50;

struct NumberTheory {
  mt19937 rng;
  void exGcd(int a, int b, int &x, int &y) {
    if (!b) {
      x = 1, y = 0;
      return;
    }
    exGcd(b, a % b, y, x), y -= a / b * x;
  }
  int inv(int a, int p = mod) {
    int x, y;
    exGcd(a, p, x, y);
    if (x < 0) x += p;
    return x;
  }
} nt;

namespace Simple {
  int n = 1;
  vector<int> fac({1, 1}), ifac({1, 1}), inv({0, 1});
  void build(int m) {
    n = m;
    fac.resize(n + 1), ifac.resize(n + 1), inv.resize(n + 1);
    inv[1] = 1;
    for (int i = 2; i <= n; ++i) inv[i] = (ll)(mod - mod / i) * inv[mod % i] % mod;
    fac[0] = ifac[0] = 1;
    for (int i = 1; i <= n; ++i) fac[i] = (ll)fac[i - 1] * i % mod, ifac[i] = (ll)ifac[i - 1] * inv[i] % mod;
  }
  void check(int k) {
    int m = n;
    if (k > m) {
      while (k > m) m <<= 1;
      build(m);
    }
  }
  int gfac(int k) {
    check(k);
    return fac[k];
  }
  int gifac(int k) {
    check(k);
    return ifac[k];
  }
  int ginv(int k) {
    check(k);
    return inv[k];
  }
}

struct SimpleSequence {
  function<int(int)> func;
  SimpleSequence(const function<int(int)> &func): func(func) {}
  int operator[](int k) const { return func(k); }
} gfac(Simple::gfac), gifac(Simple::gifac), ginv(Simple::ginv);

int binom(int n, int m) {
  if (m > n || m < 0) return 0;
  return (ll)gfac[n] * gifac[m] % mod * gifac[n - m] % mod;
}

namespace NTT {
  int L = -1;
  vector<int> root;
  void init(int l) {
    L = l;
    root.resize((1 << L) + 1);
    int n = 1 << L, *w = root.data();
    w[0] = 1, w[1 << L] = mpow(Root, 1 << (K - 2 - L));
    for (int i = L; i; --i) w[1 << (i - 1)] = (ll)w[1 << i] * w[1 << i] % mod;
    for (int i = 1; i < n; ++i) w[i] = (ll)w[i & (i - 1)] * w[i & -i] % mod;
  }
  void DIF(int *a, int l) {
    int n = 1 << l;
    for (int len = n >> 1; len; len >>= 1)
      for (int *j = a, *o = root.data(); j != a + n; j += len << 1, ++o)
        for (int *k = j; k != j + len; ++k) {
          int r = (ll)*o * k[len] % mod;
          k[len] = reduce(*k - r), add(*k, r);
        }
  }
  void DIT(int *a, int l) {
    int n = 1 << l;
    for (int len = 1; len < n; len <<= 1)
      for (int *j = a, *o = root.data(); j != a + n; j += len << 1, ++o)
        for (int *k = j; k != j + len; ++k) {
          int r = norm(*k + k[len]);
          k[len] = (ll)*o * (*k - k[len] + mod) % mod, *k = r;
        }
  }
  void fft(int *a, int lgn, int d = 1) {
    if (L < lgn) init(lgn);
    int n = 1 << lgn;
    if (d == 1) DIF(a, lgn);
    else {
      DIT(a, lgn), reverse(a + 1, a + n);
      int nInv = mod - (mod - 1) / n;
      for (int i = 0; i < n; ++i) a[i] = (ll)a[i] * nInv % mod;
    }
  }
}

struct poly {
  vector<int> a;
  poly(ll v = 0): a(1) {
    if ((v %= mod) < 0) v += mod;
    a[0] = v;
  }
  poly(const poly &o): a(o.a) {}
  poly(const vector<int> &o): a(o) {}
  poly(initializer_list<int> o): a(o) {}
  operator vector<int>() const { return a; }
  int operator[](int k) const { return k < a.size() ? a[k] : 0; }
  int &operator[](int k) {
    if (k >= a.size()) a.resize(k + 1);
    return a[k];
  }
  int deg() const { return (int)a.size() - 1; }
  void redeg(int d) { a.resize(d + 1); }
  int size() const { return a.size(); }
  void resize(int s) { a.resize(s); }
  bool empty() const { return a.empty(); }
  int back() const { return a.back(); }
  poly slice(int d) const {
    if (d < a.size()) return vector<int>(a.begin(), a.begin() + d + 1);
    vector<int> ret = a;
    ret.resize(d + 1);
    return ret;
  }
  poly shift(int k) const {
    if (size() + k <= 0) return 0;
    vector<int> ret(size() + k);
    for (int i = max(0, k); i < ret.size(); ++i) ret[i] = a[i - k];
    return ret;
  }
  int *base() { return a.data(); }
  const int *base() const { return a.data(); }

  poly operator-() const {
    poly ret = a;
    for (int i = 0; i < a.size(); ++i) ret[i] = neg(ret[i]);
    return ret;
  }
  poly operator*(const poly &) const;
  poly &operator*=(const poly &o) {
    *this = operator*(o);
    return *this;
  }
};

poly zeroes(int d) { return vector<int>(d + 1); }

namespace NTT {
  void fft(poly &a, int lgn, int d = 1) { fft(a.base(), lgn, d); }
  void fft(vector<int> &a, int lgn, int d = 1) { fft(a.data(), lgn, d); }
}

using NTT::fft;

poly poly::operator*(const poly &o) const {
  int n = deg(), m = o.deg();
  if (n == -1 || m == -1) return vector<int>();
  if (n <= 10 || m <= 10 || n + m <= BRUTE_N2_LIMIT) {
    poly ret = zeroes(n + m);
    for (int i = 0; i <= n; ++i)
      for (int j = 0; j <= m; ++j) fam(ret[i + j], a[i], o[j]);
    return ret;
  }
  n += m;
  int l = 0;
  while ((1 << l) <= n) ++l;
  poly ret = a, tmp = o;
  ret.resize(1 << l), tmp.resize(1 << l);
  fft(ret, l), fft(tmp, l);
  for (int i = 0; i < (1 << l); ++i) ret[i] = (ll)ret[i] * tmp[i] % mod;
  fft(ret, l, -1);
  return ret.slice(n);
}

struct Transposition {
  vector<int> _mul(int l, vector<int> res, const poly &b) {
    vector<int> tmp(1 << l);
    memcpy(tmp.data(), b.base(), sizeof(int) * (b.deg() + 1));
    reverse(tmp.begin() + 1, tmp.end());
    fft(tmp.data(), l);
    for (int i = 0; i < (1 << l); ++i) res[i] = (ll)res[i] * tmp[i] % mod;
    fft(res.data(), l, -1);
    return res;
  }
  poly bfMul(const poly &a, const poly &b) {
    int n = a.deg(), m = b.deg();
    poly ret = zeroes(n - m);
    for (int i = 0; i <= n - m; ++i)
      for (int j = 0; j <= m; ++j) ret[i] = (ret[i] + (ll)a[i + j] * b[j]) % mod;
    return ret;
  }
  poly mul(const poly &a, const poly &b) {
    if (a.deg() < b.deg()) return 0;
    if (a.deg() <= BRUTE_N2_LIMIT) return bfMul(a, b);
    int l = 0;
    while ((1 << l) <= a.deg()) ++l;
    vector<int> res(1 << l);
    memcpy(res.data(), a.base(), sizeof(int) * (a.deg() + 1));
    fft(res.data(), l);
    res = _mul(l, res, b);
    res.resize(a.deg() - b.deg() + 1);
    return res;
  }
} tp;

int main() {
  int n, m; scanf("%d%d", &n, &m);
  vector<vector<int>> e(n);
  for (int i = 1; i < n; ++i) {
    int u, v; scanf("%d%d", &u, &v), --u, --v, e[u].push_back(v), e[v].push_back(u);
  }
  vector<int> fa(n, -1), siz(n, 1); vector<poly> f(n);
  int ans = 0;
  if (m <= n + 1) {
    function<void(int)> dfs = [&](int u) {
      f[u] = poly(1).slice(m - 1);
      for (int v : e[u])
        if (v != fa[u])
          fa[v] = u, dfs(v), f[u] = (f[u] * f[v]).slice(m - 1), siz[u] += siz[v];
      for (int i = 1; i < m; ++i) add(f[u][i], f[u][i - 1]);
      int fix = mpow(m, siz[u]);
      for (int i = 0; i < m; ++i) sub(fix, f[u][i]);
      f[u].redeg(m), reverse(f[u].base(), f[u].base() + m + 1), add(f[u][0], fix);
      for (int i = 1; i <= m; ++i) ans = (ans + (ll)f[u][i] * i % mod * mpow(m, n - siz[u])) % mod;
    }; dfs(0);
  } else {
    vector<int> fac(n * 3 + 2), ifac(n * 3 + 2);
    fac[0] = m - n - 1;
    for (int i = 1; i <= n * 3 + 1; ++i) fac[i] = (ll)fac[i - 1] * (m - n - 1 + i) % mod;
    ifac[n * 3 + 1] = mpow(fac[n * 3 + 1], mod - 2);
    for (int i = n * 3 + 1; i; --i) ifac[i - 1] = (ll)ifac[i] * (m - n - 1 + i) % mod;
    function<void(int)> dfs = [&](int u) {
      f[u] = 1;
      for (int v : e[u])
        if (v != fa[u])
          fa[v] = u, dfs(v), f[u] *= f[v], siz[u] += siz[v];
      int fix = mpow(m, siz[u]);
      for (int i = 0; i < siz[u]; ++i)
        fix = (fix + (ll)(mod - f[u][i]) * fac[n - i + siz[u]] % mod * ifac[n - i] % mod * gifac[siz[u]]) % mod;
      poly g = zeroes(siz[u] * 2 - 2);
      for (int i = -siz[u] + 1; i < siz[u]; ++i) g[siz[u] - 1 + i] = (ll)fac[n + i + siz[u]] * ifac[n + i + 1] % mod;
      reverse(f[u].base(), f[u].base() + siz[u]);
      g = -tp.mul(g, f[u]) * gifac[siz[u] - 1];
      poly h = zeroes(siz[u]);
      for (int i = 0; i <= siz[u]; ++i) h[i] = i & 1 ? mod - binom(siz[u], i) : binom(siz[u], i);
      g = (g * h.slice(siz[u] - 1)).slice(siz[u] - 1);
      if (siz[u] & 1) g = -g;
      g.redeg(siz[u]), reverse(g.base(), g.base() + siz[u] + 1), f[u] = g;
      for (int i = 0; i <= siz[u]; ++i) f[u][i] = (f[u][i] + (ll)fix * h[i]) % mod;
      int s = 0;
      for (int i = 0; i <= siz[u]; ++i)
        s = (s + ((ll)i * (siz[u] + 1) + (ll)siz[u] * (m - i)) % mod * ifac[n - i + 1] % mod * fac[n - i + siz[u] + 1] % mod * f[u][i]) % mod;
      ans = (ans + (ll)s * mpow(m, n - siz[u]) % mod * gifac[siz[u] + 1]) % mod;
    }; dfs(0);
  }
  printf("%d\n", ans);
}