A subarray of array a from index l to the index r is the array [a_l, a_{l+1}, ..., a_{r}]. The number of occurrences of the array b in the array a is the number of subarrays of a such that they are equal to b.

You are given n arrays A_1, A_2, ..., A_n; the elements of these arrays are integers from 1 to k. You have to build an array a consisting of m integers from 1 to k in such a way that, for every given subarray A_i, the number of occurrences of A_i in the array a is not less than the number of occurrences of each non-empty subarray of A_i in a. Note that if A_i doesn't occur in a, and no subarray of A_i occurs in a, this condition is still met for A_i.

Your task is to calculate the number of different arrays a you can build, and print it modulo 998244353.

Input

The first line contains three integers n, m and k (1 ≤ n, m, k ≤ 3 ⋅ 10^5) — the number of the given arrays, the desired length of the array a, and the upper bound on the values in the arrays.

Then n lines follow. The i-th line represents the array A_i. The first integer in the i-th line is c_i (1 ≤ c_i ≤ m) — the number of elements in A_i; then, c_i integers from 1 to k follow — the elements of the array A_i.

Additional constraint on the input: ∑_{i=1}^n c_i ≤ 3 ⋅ 10^5; i. e., the number of elements in the given arrays in total does not exceed 3 ⋅ 10^5.

Output

Print one integer — the number of different arrays a you can build, taken modulo 998244353.

Examples

Input


2 4 3
2 1 2
1 3


Output


5


Input


2 4 3
2 1 2
3 3 2 1


Output


0


Input


1 42 1337
2 13 31


Output


721234447
#include <bits/stdc++.h>
using namespace std;
template <int MOD_>
struct modnum {
  static constexpr int MOD = MOD_;
  static_assert(MOD_ > 0, "MOD must be positive");

 private:
  using ll = long long;
  int v;
  static int minv(int a, int m) {
    a %= m;
    assert(a);
    return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
  }

 public:
  modnum() : v(0) {}
  modnum(ll v_) : v(int(v_ % MOD)) {
    if (v < 0) v += MOD;
  }
  explicit operator int() const { return v; }
  friend std::ostream& operator<<(std::ostream& out, const modnum& n) {
    return out << int(n);
  }
  friend std::istream& operator>>(std::istream& in, modnum& n) {
    ll v_;
    in >> v_;
    n = modnum(v_);
    return in;
  }
  friend bool operator==(const modnum& a, const modnum& b) {
    return a.v == b.v;
  }
  friend bool operator!=(const modnum& a, const modnum& b) {
    return a.v != b.v;
  }
  modnum inv() const {
    modnum res;
    res.v = minv(v, MOD);
    return res;
  }
  friend modnum inv(const modnum& m) { return m.inv(); }
  modnum neg() const {
    modnum res;
    res.v = v ? MOD - v : 0;
    return res;
  }
  friend modnum neg(const modnum& m) { return m.neg(); }
  modnum operator-() const { return neg(); }
  modnum operator+() const { return modnum(*this); }
  modnum& operator++() {
    v++;
    if (v == MOD) v = 0;
    return *this;
  }
  modnum& operator--() {
    if (v == 0) v = MOD;
    v--;
    return *this;
  }
  modnum& operator+=(const modnum& o) {
    v += o.v;
    if (v >= MOD) v -= MOD;
    return *this;
  }
  modnum& operator-=(const modnum& o) {
    v -= o.v;
    if (v < 0) v += MOD;
    return *this;
  }
  modnum& operator*=(const modnum& o) {
    v = int(ll(v) * ll(o.v) % MOD);
    return *this;
  }
  modnum& operator/=(const modnum& o) { return *this *= o.inv(); }
  friend modnum operator++(modnum& a, int) {
    modnum r = a;
    ++a;
    return r;
  }
  friend modnum operator--(modnum& a, int) {
    modnum r = a;
    --a;
    return r;
  }
  friend modnum operator+(const modnum& a, const modnum& b) {
    return modnum(a) += b;
  }
  friend modnum operator-(const modnum& a, const modnum& b) {
    return modnum(a) -= b;
  }
  friend modnum operator*(const modnum& a, const modnum& b) {
    return modnum(a) *= b;
  }
  friend modnum operator/(const modnum& a, const modnum& b) {
    return modnum(a) /= b;
  }
};
template <typename T>
T pow(T a, long long b) {
  assert(b >= 0);
  T r = 1;
  while (b) {
    if (b & 1) r *= a;
    b >>= 1;
    a *= a;
  }
  return r;
}
template <int M>
string to_string(modnum<M> x) {
  return to_string(int(x));
}
using num = modnum<998244353>;
vector<num> fact, invFact;
void initFact(int n) {
  fact.resize(n + 2);
  invFact.resize(n + 2);
  fact[0] = 1;
  for (int i = 1; i <= n + 1; i++) fact[i] = fact[i - 1] * i;
  invFact[n + 1] = inv(fact[n + 1]);
  for (int i = n; i >= 0; i--) invFact[i] = invFact[i + 1] * (i + 1);
}
num c(int n, int k) {
  return 0 <= k && k <= n ? fact[n] * invFact[k] * invFact[n - k] : 0;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  initFact(3e5);
  int n, m, k, noAns = 0;
  cin >> n >> m >> k;
  vector<vector<int>> a(n);
  vector<int> c(n);
  vector<int> isFirst(k, -1), isLast(k, -1), cnt(k), l(n, -1), r(n, -1);
  for (int i = 0; i < n; i++) {
    cin >> c[i];
    a[i].resize(c[i]);
    for (int j = 0; j < c[i]; j++) {
      cin >> a[i][j];
      --a[i][j];
    }
    if (c[i] == 1) continue;
    int x = a[i][0];
    if (isLast[x] >= 0) {
      r[isLast[x]] = i;
      l[i] = isLast[x];
    }
    isFirst[x] = i;
    int y = a[i][c[i] - 1];
    if (isFirst[y] >= 0) {
      r[i] = isFirst[y];
      l[isFirst[y]] = i;
    }
    isLast[y] = i;
    vector<int> tmp = a[i];
    sort(begin(tmp), end(tmp));
    for (int j = 0; j < c[i]; j++) {
      if (j && tmp[j] == tmp[j - 1]) noAns = 1;
      cnt[tmp[j]]++;
    }
  }
  for (int i = 0; i < k; i++)
    if (cnt[i] > 2)
      noAns = 1;
    else if (cnt[i] == 2 && (isFirst[i] < 0 || isLast[i] < 0))
      noAns = 1;
  if (noAns) {
    cout << 0 << endl;
    return 0;
  }
  vector<int> chainCnt(m + 1);
  for (int i = 0; i < k; i++)
    if (isFirst[i] >= 0 && l[isFirst[i]] < 0) {
      int x = isFirst[i], len = c[x];
      while (r[x] >= 0) {
        x = r[x];
        len += c[x] - 1;
      }
      if (len <= m) chainCnt[len]++;
    } else if (!cnt[i])
      chainCnt[1]++;
  vector<int> chainLengths;
  for (int i = 1; i <= m; i++)
    if (chainCnt[i]) chainLengths.push_back(i);
  vector<num> f(m + 1);
  f[0] = 1;
  for (int i = 1; i <= m; i++)
    for (int len : chainLengths)
      if (len <= i) f[i] += f[i - len] * chainCnt[len];
  cout << f[m] << endl;
}
