#include <bits/stdc++.h>
using namespace std;
using LL = long long;
namespace _buff {
const size_t BUFF = 1 << 19;
char buff[BUFF], *begin = buff, *end = buff;
char getc() {
  if (begin == end) {
    begin = buff;
    end = buff + fread(buff, 1, BUFF, stdin);
  }
  return begin == end ? -1 : *begin++;
}
}  // namespace _buff
LL read() {
  using namespace _buff;
  LL ret = 0;
  bool pos = true;
  char c = getc();
  for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
    assert(~c);
  }
  if (c == '-') {
    pos = false;
    c = getc();
  }
  for (; c >= '0' && c <= '9'; c = getc()) {
    ret = (ret << 3) + (ret << 1) + (c ^ 48);
  }
  return pos ? ret : -ret;
}
const size_t N = 1 << 19;
const int MOD = 998244353;
const int ROOT = 3;
int qpow(int base, int e) {
  int ret = 1;
  for (; e; e >>= 1) {
    if (e & 1) ret = 1LL * ret * base % MOD;
    base = 1LL * base * base % MOD;
  }
  return ret;
}
int rmod(int x) {
  if (x >= MOD) x -= MOD;
  if (x < 0) x += MOD;
  return x;
}
void fft(int a[], int lg, int flag) {
  static int rev[N], rev_lg = -1;
  int n = 1 << lg;
  if (lg != rev_lg) {
    for (int i = 0; i < n; ++i) {
      rev[i] = rev[i >> 1] >> 1 | ((i & 1) << (lg - 1));
    }
  }
  for (int i = 0; i < n; ++i) {
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  }
  for (int m = 1, l = 2; m < n; m <<= 1, l <<= 1) {
    int wn = qpow(ROOT, flag ? (MOD - 1) - (MOD - 1) / l : (MOD - 1) / l);
    for (int i = 0, j, w, x, y; i < n; i += l) {
      for (j = 0, w = 1; j < m; ++j, w = 1LL * w * wn % MOD) {
        x = a[i + j];
        y = 1LL * w * a[i + j + m] % MOD;
        a[i + j] = rmod(x + y);
        a[i + j + m] = rmod(x - y);
      }
    }
  }
  if (flag) {
    int inv = qpow(n, MOD - 2);
    for (int i = 0; i < n; ++i) {
      a[i] = 1LL * a[i] * inv % MOD;
    }
  }
}
vector<int> operator*(const vector<int> &a, const vector<int> &b) {
  static int aa[N], bb[N], cc[N];
  int n = a.size(), m = b.size(), l = n + m - 1, lg = 0;
  vector<int> ans(l);
  if (static_cast<LL>(n) * m <= 4096) {
    static unsigned long long tmp[N];
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < m; ++j) {
        if ((tmp[i + j] += static_cast<unsigned long long>(a[i]) * b[j]) >>
            62) {
          tmp[i + j] %= MOD;
        }
      }
    }
    for (int i = 0; i < l; ++i) {
      ans[i] = tmp[i] % MOD;
      tmp[i] = 0;
    }
    return ans;
  }
  for (; (1 << lg) < l; ++lg) {
  }
  memset(aa, 0, sizeof(int) << lg);
  copy(a.begin(), a.end(), aa);
  fft(aa, lg, 0);
  memset(bb, 0, sizeof(int) << lg);
  copy(b.begin(), b.end(), bb);
  fft(bb, lg, 0);
  for (int i = 0, _ = 1 << lg; i < _; ++i) {
    cc[i] = 1LL * aa[i] * bb[i] % MOD;
  }
  fft(cc, lg, 1);
  copy(cc, cc + l, ans.begin());
  return ans;
}
vector<int> operator+(const vector<int> &a, const vector<int> &b) {
  const vector<int> &aa = a.size() > b.size() ? a : b;
  const vector<int> &bb = a.size() > b.size() ? b : a;
  vector<int> ret(aa);
  auto it = ret.begin();
  auto jt = bb.begin();
  for (; jt != bb.end(); ++it, ++jt) {
    *it = rmod(*it + *jt);
  }
  return ret;
}
vector<int> g[N];
int pa[N], dep[N], nxt[N], sz[N];
void dfs1(int u) {
  sz[u] = 1;
  for (int v : g[u]) {
    if (v == pa[u]) continue;
    pa[v] = u;
    dep[v] = dep[u] + 1;
    dfs1(v);
    sz[u] += sz[v];
    if (sz[v] > sz[nxt[u]]) nxt[u] = v;
  }
}
vector<int> polys[N];
pair<vector<int>, vector<int> > solve(const vector<int> &idx, int l, int r) {
  if (l + 1 == r) {
    return {polys[idx[l]], polys[idx[l]]};
  }
  int mid = (l + r) >> 1;
  auto ans1 = solve(idx, l, mid), ans2 = solve(idx, mid, r);
  return {ans1.first + ans2.first * ans1.second, ans1.second * ans2.second};
}
void dfs2(int u) {
  assert(!pa[u] || nxt[pa[u]] != u);
  vector<int> idx(1, u);
  for (int v = nxt[u]; v; v = nxt[v]) {
    idx.emplace_back(v);
  }
  for (int u : idx) {
    polys[u] = {0, 1};
    for (int v : g[u]) {
      if (v == pa[u] || v == nxt[u]) continue;
      dfs2(v);
      polys[v][0] += 1;
      polys[u] = polys[u] * polys[v];
    }
  }
  polys[u] = solve(idx, 0, idx.size()).first;
}
int main() {
  int n = read();
  LL x = read();
  for (int i = 1, a, b; i < n; ++i) {
    a = read();
    b = read();
    g[a].emplace_back(b);
    g[b].emplace_back(a);
  }
  dfs1(1);
  dfs2(1);
  vector<int> &vc = polys[1];
  int ans = 0, mul = 1;
  for (unsigned i = 1; i < vc.size(); ++i) {
    ans = (ans + 1LL * mul * vc[i]) % MOD;
    mul = (x + i) % MOD * qpow(i, MOD - 2) % MOD * mul % MOD;
  }
  printf("%d\n", ans);
  return 0;
}
