// Author: Klay Thompson
// Problem: M. Do Not Turn Back
// Memory Limit: 1024 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#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 SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;

template<class T>inline void chkmn(T &x, T y) { if (y < x) x = y; }
template<class T>inline void chkmx(T &x, T y) { if (y > x) x = y; }

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>;

const int maxn = 510;

using poly = vector<Z>;

poly BM(poly a) {
  poly b({1}), c({0});
  Z d = 1;
  rep (i, 0, SZ(a) - 1) {
    int n = SZ(b);
    Z w = 0;
    rep (j, 0, n - 1) w += a[i - (n - 1) + j] * b[j];
    c.emplace_back(0);
    if (!w.val()) continue;
    int m = SZ(c);
    Z e = -w / d;
    if (m > n) {
      auto tmp = b;
      b.insert(b.begin(), m - n, 0);
      rep (j, 0, m - 1) b[j] += e * c[j];
      c = tmp, d = w;
    } else {
      rep (j, 0, m - 1) b[n - m + j] += e * c[j];
    }
  }
  return b;
}

poly mul(poly f, poly g) {
  int n = SZ(f), m = SZ(g);
  poly res(n + m - 1, 0);
  rep (i, 0, n - 1) rep (j, 0, m - 1) res[i + j] += f[i] * g[j];
  return res;
}

poly mod(poly f, poly g) {
  int n = SZ(f), m = SZ(g);
  Z inv = g.back().inv();
  per (i, n - 1, m) {
    Z coe = f[i] * inv;
    rep (j, 0, m - 1) f[i - (m - 1) + j] -= coe * g[j];
  }
  return f.resize(m), f;
}

poly fpw(poly a, ll k, poly p) {
  poly res({1});
  while (k) {
    if (k & 1) res = mod(mul(res, a), p);
    a = mod(mul(a, a), p), k >>= 1;
  }
  return res;
}

int n, m, k, deg[maxn];
vector<int> ed[maxn];
Z f[3][maxn];

struct mat {
  Z a[maxn][maxn];
  friend mat operator*(mat x, mat y) {
    mat res;
    rep (i, 1, 2 * n) rep (k, 1, 2 * n) if (x.a[i][k].val()) {
      rep (j, 1, 2 * n) res.a[i][j] += x.a[i][k] * y.a[k][j];
    }
    return res;
  }
} e, pw[30];

struct vec {
  Z a[maxn];
  friend vec operator*(vec x, mat y) {
    vec res;
    rep (i, 1, 2 * n) {
      rep (j, 1, 2 * n) res.a[j] += x.a[i] * y.a[i][j];
    }
    return res;
  }
};

Z solve(int k, poly coe, poly tmp) {
  if (k <= 2) return f[k][n];
  auto res = fpw(poly({0, 1}), k - 2, coe);
  Z ans = 0;
  rep (i, 0, SZ(res) - 1) ans += tmp[i] * res[i];
  return ans;
}

int main() {
  cin.tie(nullptr) -> ios::sync_with_stdio(false);
  cin >> n >> m >> k;
  rep (i, 1, m) {
    int u, v;
    cin >> u >> v;
    ed[u].emplace_back(v);
    ed[v].emplace_back(u);
  }
  rep (i, 1, n) {
    sort(ALL(ed[i]));
    ed[i].erase(unique(ALL(ed[i])), ed[i].end());
    deg[i] = SZ(ed[i]);
  }
  f[0][1] = 1;
  for (int u : ed[1]) f[1][u] += 1;
  for (int u : ed[1]) for (int v : ed[u]) if (v != 1) f[2][v] += 1;
  rep (u, 1, n) {
    for (int v : ed[u]) e.a[v][u] += 1;
    e.a[u + n][u] += 1 - deg[u], e.a[u][n + u] += 1;
  }
  vec res;
  rep (i, 1, n) res.a[i] = f[2][i], res.a[i + n] = f[1][i];
  vector<Z> tmp;
  rep (w, 0, 5 * n) {
    tmp.emplace_back(res.a[n]);
    res = res * e;
  }
  auto coe = BM(tmp);
  cout << solve(k, coe, tmp).val() << '\n';
}