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



namespace LOJ177 {
  const int maxn = 210;
  mt19937 rnd(random_device{}());
  
  int n, m, tot, a[maxn][maxn], vis[maxn], p[maxn * maxn];
  
  struct perm {
    int a[maxn];
    friend perm operator*(perm x, perm y) {
      perm res;
      rep (i, 1, n) res.a[i] = y.a[x.a[i]];
      return res;
    }
    perm inv() {
      perm res;
      rep (i, 1, n) res.a[a[i]] = i;
      return res;
    }
  } val[maxn], b[maxn * maxn];
  
  vector<pair<int, perm>> e[maxn];
  
  void dfs(int u, int fa) {
    vis[u] = 1;
    for (auto [v, w] : e[u]) {
      if (v == fa || vis[v]) continue;
      val[v] = val[u] * w, dfs(v, u);
    }
  }
  
  Z solve() {
    while (m <= 4 * n) {
      m++;
      rep (i, 1, n) a[m][i] = i;
    }
    Z ans = Z(1);
    while (n > 1) {
      rep (i, 1, n) e[i].clear(), vis[i] = 0;
      rep (i, 1, n) rep (j, 1, m) {
        perm cur;
        rep (k, 1, n) cur.a[k] = a[j][k];
        e[i].emplace_back(a[j][i], cur);
      }
      rep (i, 1, n) val[1].a[i] = i;
      dfs(1, 0), tot = 0;
      int cnt = 0;
      rep (i, 1, n) if (vis[i]) cnt++;
      ans = ans * cnt;
      rep (u, 1, n) for (auto [v, w] : e[u]) {
        if (!vis[u] || !vis[v]) continue;
        b[++tot] = val[u] * w * val[v].inv();
      }
      n--;
      rep (i, 1, tot) {
        rep (j, 1, n) b[i].a[j] = b[i].a[j + 1] - 1;
      }
      m = 0;
      while (m < 4 * n) {
        perm cur;
        rep (i, 1, n) cur.a[i] = i;
        rep (i, 1, tot) p[i] = i;
        shuffle(p + 1, p + tot + 1, rnd);
        rep (i, 1, tot) if (rnd() & 1) cur = cur * b[p[i]];
        m++;
        rep (i, 1, n) a[m][i] = cur.a[i];
      }
    }
    return ans;
  }
}

const int maxn = 310;
const int maxm = maxn * maxn;
mt19937 rnd(random_device{}());

int n, k, a[maxn][maxn], p[maxn], b[maxn], c[maxn], id[maxn][maxn], tot, fa[maxm], c0[maxm], c1[maxm];

int find(int x) {
  return fa[x] == x ? x : fa[x] = find(fa[x]);
}

int main() {
  cin.tie(nullptr) -> ios::sync_with_stdio(false);
  cin >> n >> k;
  rep (i, 1, k) rep (j, 1, n) cin >> a[i][j];
  LOJ177::n = n, LOJ177::m = k;
  rep (i, 1, k) rep (j, 1, n) LOJ177::a[i][j] = a[i][j];
  Z base = LOJ177::solve();
  rep (i, 1, k) p[i] = i;
  rep (i, 1, n) rep (j, 1, n) if (i != j) id[i][j] = ++tot;
  rep (i, 1, tot) fa[i] = i;
  rep (_, 1, 50) {
    shuffle(p + 1, p + k + 1, rnd);
    rep (i, 1, n) b[i] = i;
    rep (i, 1, k) if (rnd() & 1) {
      rep (j, 1, n) c[j] = b[a[i][j]];
      rep (j, 1, n) b[j] = c[j];
    }
    rep (i, 1, n) rep (j, 1, n) if (i != j) fa[find(id[i][j])] = find(id[b[i]][b[j]]);
  }
  rep (i, 1, n) rep (j, 1, n) if (i < j) c0[find(id[i][j])]++;
  rep (i, 1, n) rep (j, 1, n) if (i > j) c1[find(id[i][j])]++;
  Z ans = 0;
  rep (i, 1, tot) if (find(i) == i) ans += Z(c0[i]) * c1[i] / (c0[i] + c1[i]);
  cout << (ans * base).val() << '\n';
}