#include <bits/stdc++.h>

using namespace std;

// #define LOCK_GETCHAR
// #define USE_INT_128

#if __cplusplus < 201400
#warning "Please use c++14 or higher."
#define CONSTEXPR_FUNC
#define ENABLE_IF_INT
#else
#define CONSTEXPR_FUNC constexpr
#define ENABLE_IF_INT , enable_if_t<_is_integer<T>, int> = 0
template <class T> constexpr bool _is_integer = numeric_limits<T>::is_integer;
template <> constexpr bool _is_integer<bool> = false;
template <> constexpr bool _is_integer<char> = false;
#ifdef USE_INT_128
template <> constexpr bool _is_integer<__int128> = true;
template <> constexpr bool _is_integer<__uint128_t> = true;
#endif
#endif

#if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(LOCK_GETCHAR)
#define getchar getchar_unlocked
#endif

#define il inline
#define mkp make_pair
#define fi first
#define se second
#define ssz(x) (signed((x).size()))
#define _loop_i_t(j, k) make_signed_t<decltype((j) - (k))>
#define For(i, j, k) for (_loop_i_t(j, k) i = (j); i <= (k); ++i) // NOLINT
#define ForDown(i, j, k)                                                       \
  for (_loop_i_t(j, k) i = (j); i >= decltype(i)(k); --i) // NOLINT
#define eb emplace_back
#ifndef ONLINE_JUDGE
#define FileIO(filename)                                                       \
  freopen(filename ".in", "r", stdin);                                         \
  freopen(filename ".out", "w", stdout)
#else
#define FileIO(filename) void(0)
#endif

using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using db = double;
using ldb = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#ifdef USE_INT_128
using lll = __int128_t;
using ulll = __uint128_t;
#endif

// clang-format off
CONSTEXPR_FUNC il ll qpow(ll x, ull y, ll mod){ ll ans = 1; x %= mod; while (y) { if (y & 1) (ans *= x) %= mod; (x *= x) %= mod; y >>= 1; } return ans; }
template<typename T> CONSTEXPR_FUNC il void cmin(T & x, const T &y){ x = min(x, y); }
template<typename T> CONSTEXPR_FUNC il void cmax(T & x, const T &y){ x = max(x, y); }
template<typename T ENABLE_IF_INT> il void read(T &x){ x = 0; int f = 1; int c = getchar(); while (!isdigit(c)) { if (c == '-') f = -1; c = getchar(); } while (isdigit(c)) { x = x * 10 + (c - '0'); c = getchar(); } x *= f; }
template<typename T, typename ... Args> il void read(T &x, Args &... y){ read(x), read(y...); }
// clang-format on

// File head end

namespace {

struct chash { // large odd number for C
  const uint64_t C = ull(4e18 * acos(0)) | 71;
  ull operator()(ull x) const { return __builtin_bswap64(x * C); }
  ull operator()(pii x) const {
    return this->operator()(ull(x.fi) << 32 | x.se);
  }
};
struct null_type {
  char _[0];
};
const int SZ = 1 << 15;
template <typename U, typename V> struct hash_map {
  struct data {
    U u;
    V v;
    int nex;
  };
  data e[SZ];
  bitset<SZ> vis;
  int h[SZ], cnt;
  inline int hash(U u) { return chash{}(u) & (SZ - 1); }
  inline bool count(U u) {
    int hu = hash(u);
    for (int i = h[hu]; i; i = e[i].nex)
      if (e[i].u == u)
        return 1;
    return 0;
  }
  inline void clear() {
    if (cnt <= (SZ >> 1))
      for (int i = 1; i <= cnt; i++)
        h[hash(e[i].u)] = 0, vis[hash(e[i].u)] = 0;
    else
      memset(h, 0, sizeof(h)), vis.reset();
    cnt = 0;
  }
  inline int size() { return cnt; }
  V &operator[](U u) {
    int hu = hash(u);
    for (int i = h[hu]; i; i = e[i].nex)
      if (e[i].u == u)
        return e[i].v;
    return e[++cnt] = (data){u, {}, h[hu]}, h[hu] = cnt, vis[hu] = 1, e[cnt].v;
  }
  struct iterator {
    int _p, _q;
    const hash_map *self;
    tuple<const U &, const V &> operator*() const {
      return tie(self->e[_q].u, self->e[_q].v);
    }
    iterator &operator++() {
      _q = self->e[_q].nex;
      if (!_q) {
        _p = self->vis._Find_next(_p);
        if (_p < SZ)
          _q = self->h[_p];
      }
      return *this;
    }
    bool operator!=(const iterator &rhs) const {
      return self != rhs.self || _q != rhs._q;
    }
  };
  iterator begin() const {
    int p = vis._Find_first();
    int q = (p == SZ) ? 0 : h[p];
    return {p, q, this};
  }
  iterator end() const { return {SZ, 0, this}; }
};

constexpr ll MAXN = 5005, MAXK = 1005, mod = 998244353;

[[gnu::always_inline]] il void add(int &x, int y) {
  ((x += y) >= mod) ? (x -= mod) : 0;
}
[[gnu::always_inline]] il void fma_mod(int &x, int y, int z) {
  x = (x + ll(y) * z) % mod;
}

int p, k, n;
vector<int> T[MAXK][MAXN];

namespace Sol1 {
bitset<MAXN> G[MAXN];
vector<int> tr[MAXN * 2], st;
int dfn[MAXN], low[MAXN], bcc = 0, cnt = 0;
int S[2][MAXN], pre1[MAXN], pre2[MAXN], f[MAXN * 2][3], g[2][5][5], h[MAXN],
    fac[MAXN], ifac[MAXN], pw[MAXN][MAXN];
ll C(int x, int y) { return ll(fac[x]) * ifac[y] % mod * ifac[x - y] % mod; }
void trans(vector<int> *tr) {
  auto dfs = [&](auto &&self, int x, int pre) -> void {
    int tmp, top = pre;
    while (!pre || ssz(tr[x]) == 2)
      tmp = x, x = tr[x][tr[x][0] == pre], pre = tmp;
    if (x != top)
      G[top][x] = G[x][top] = 1;
    for (int v : tr[x])
      if (v != pre)
        self(self, v, x);
  };
  int p = 1;
  while (ssz(tr[p]) != 1)
    p++;
  For(i, 1, n) for (int j : tr[i]) G[i][j] = 1;
  dfs(dfs, p, p);
}
void dfs1(int x) {
  st.eb(x), dfn[x] = low[x] = ++cnt;
  for (int v = G[x]._Find_first(); v < ssz(G[x]); v = G[x]._Find_next(v)) {
    if (!dfn[v]) {
      dfs1(v), cmin(low[x], low[v]);
      if (low[v] >= dfn[x]) {
        ++bcc;
        int u;
        tr[n + bcc].eb(x), tr[x].eb(n + bcc);
        do {
          u = st.back(), st.pop_back();
          tr[n + bcc].eb(u), tr[u].eb(n + bcc);
        } while (u != v);
      }
    } else
      cmin(low[x], dfn[v]);
  }
}
void dfs2(int x) {
  if (tr[x].empty())
    return assert(x <= n), f[x][0] = 1, void();
  for (int v : tr[x])
    tr[v].erase(find(tr[v].begin(), tr[v].end(), x)), dfs2(v);
  int tmp[3];
  f[x][0] = 1;
  for (int v : tr[x]) {
    tmp[0] = ll(f[x][0]) * f[v][0] % mod;
    tmp[1] = (ll(f[x][1]) * f[v][0] + ll(f[x][0]) * f[v][1]) % mod;
    tmp[2] = (ll(f[x][2]) * f[v][0] + ll(f[x][1]) * f[v][1] +
              ll(f[x][0]) * f[v][2]) %
             mod;
    f[x][0] = tmp[0], f[x][1] = tmp[1], f[x][2] = tmp[2];
  }
  if (x <= n) {
    f[x][0] = f[x][1] = 0;
    int sz = 0;
    memset(g[0], 0, sizeof g[0]);
    memset(h, 0, (n + 1) * sizeof(int));
    g[0][0][0] = h[0] = 1;
    for (int v : tr[x]) {
      int cur = (sz & 1) ^ 1, pre = sz & 1;
      memset(g[cur], 0, sizeof g[cur]);
      For(i, 0, min(sz, 2)) For(j, 0, min(sz, 2)) {
        int val = g[pre][i][j];
        fma_mod(g[cur][i + 1][j], val, f[v][0]);
        fma_mod(g[cur][i][j], ll(val) * (i + j) % mod, f[v][0]);
        fma_mod(g[cur][i][j + 1], val, f[v][1]);
        if (i)
          fma_mod(g[cur][i - 1][j + 1], ll(val) * i % mod, f[v][1]);
      }
      ForDown(i, sz, 0) {
        fma_mod(h[i + 1], h[i], f[v][1]);
        h[i] = ll(h[i]) * f[v][0] % mod;
      }
      sz++;
    }
    For(i, 0, sz) {
      For(j, 0, sz - i) {
        ll mul = ll(C(sz - i, j)) * pw[i][j] % mod * h[i] % mod;
        f[x][1] = (f[x][1] + mul * (pre1[sz - i - j] + pre2[sz - i - j])) % mod;
        f[x][2] = (f[x][2] + mul * pre1[sz - i - j] % mod * i) % mod;
      }
    }
    int cur = sz & 1;
    assert(!g[cur][0][0]);
    f[x][0] = g[cur][1][0];
    add(f[x][1], mod - g[cur][1][0]);
    For(i, 0, sz) For(j, 0, 2 - i) {
      int v = g[cur][i][j];
      if (i)
        fma_mod(f[x][1], v, mod - i);
      if (j)
        fma_mod(f[x][2], v, mod - j);
    }
  }
}
void solve() {
  fac[0] = 1;
  For(i, 1, n) fac[i] = fac[i - 1] * ll(i) % mod;
  ifac[n] = qpow(fac[n], mod - 2, mod);
  ForDown(i, n, 1) ifac[i - 1] = ifac[i] * ll(i) % mod;
  S[0][0] = 1;
  For(i, 0, n) pre1[0] = 1;
  For(i, 1, n) {
    int cur = i & 1, pre = cur ^ 1;
    S[cur][0] = 0;
    For(j, 1, i) {
      S[cur][j] = (S[pre][j - 1] + ll(j) * S[pre][j]) % mod;
      pre1[i] = (pre1[i] + S[cur][j]) % mod;
      pre2[i] = (pre2[i] + ll(j) * S[cur][j]) % mod;
    }
  }
  pw[0][0] = 1;
  For(i, 1, n) {
    pw[i][0] = 1;
    For(j, 1, n) pw[i][j] = ll(pw[i][j - 1]) * i % mod;
  }
  For(i, 1, k) trans(T[i]);
  dfs1(1), assert(bcc), dfs2(n + 1);
  cout << (ll(f[n + 1][0]) + f[n + 1][1] + f[n + 1][2]) % mod << '\n';
}
} // namespace Sol1
namespace Sol2 {
vector<int> cur[MAXN * 2], ins[MAXN * 2], nxt[MAXN * 2];
int cur_sz, ins_sz;
int trans(vector<int> *tr, vector<int> *dist) {
  For(i, 1, 2 * n) dist[i].clear();
  int cnt = 0;
  auto dfs = [&](auto &&self, int x, int pre) -> void {
    cnt++;
    int tmp;
    if (pre)
      dist[n + cnt].eb(pre), dist[pre].eb(n + cnt);
    while (!pre || ssz(tr[x]) == 2)
      dist[n + cnt].eb(x), dist[x].eb(n + cnt),
          tmp = x, x = tr[x][tr[x][0] == pre], pre = tmp;
    dist[n + cnt].eb(x), dist[x].eb(n + cnt);
    for (int v : tr[x])
      if (v != pre)
        self(self, v, x);
  };
  int p = 1;
  while (ssz(tr[p]) != 1)
    p++;
  dfs(dfs, p, 0);
  return n + cnt;
}
hash_map<pii, vector<int>> mp;
hash_map<pii, null_type> have;
int bl[MAXN], fa[MAXN * 2];
void merge() {
  mp.clear(), have.clear();
  fill(bl, bl + 1 + n, -1);
  auto dfs1 = [&](auto &&self, int x, int pre) -> void {
    fa[x] = pre;
    if (x > n)
      for (int v : cur[x])
        if (v != pre)
          bl[v] = x - n;
    for (int v : cur[x])
      if (v != pre)
        self(self, v, x);
  };
  assert(cur_sz > n);
  dfs1(dfs1, n + 1, 0);
  For(i, n + 1, ins_sz) for (int u : ins[i]) {
    if (~bl[u])
      mp[{bl[u], i - n}].eb(u);
    have[{i - n, u}] = {};
  }
  int cnt2 = 0;
  For(i, 1, 2 * n) nxt[i].clear();
  for (const auto &[key, vec] : mp) {
    if (ssz(vec) > 1) {
      cnt2++;
      for (int u : vec)
        nxt[u].eb(n + cnt2), nxt[n + cnt2].eb(u);
      if (have.count({key.se, fa[key.fi + n]}))
        nxt[fa[key.fi + n]].eb(n + cnt2), nxt[n + cnt2].eb(fa[key.fi + n]);
    } else if (have.count({key.se, fa[key.fi + n]})) {
      cnt2++;
      nxt[vec[0]].eb(n + cnt2), nxt[n + cnt2].eb(vec[0]);
      nxt[fa[key.fi + n]].eb(n + cnt2), nxt[n + cnt2].eb(fa[key.fi + n]);
    }
  }
  cur_sz = cnt2 + n;
  For(i, 1, 2 * n) cur[i].swap(nxt[i]);
}
void solve() {
  cur_sz = trans(T[1], cur);
  For(i, 2, k) {
    ins_sz = trans(T[i], ins);
    merge();
  }
  ll ans = 1;
  For(i, n + 1, cur_sz) {
    if (ssz(cur[i]) > 1)
      (ans *= qpow(ssz(cur[i]), ssz(cur[i]) - 2, mod)) %= mod;
  }
  cout << ans << '\n';
}
} // namespace Sol2

void Main() {
  read(p, k, n);
  For(i, 1, k) For(j, 1, n - 1) {
    int u, v;
    read(u, v), T[i][u].eb(v), T[i][v].eb(u);
  }
  (p == 0) ? Sol1::solve() : Sol2::solve();
}
} // namespace

signed main() { return Main(), 0; }