#include <bits/stdc++.h>

using namespace std;

typedef long long i64;
typedef unsigned long long u64;
typedef double lf;

typedef vector<int> perm;

vector<int> inv(const vector<int>& p){
    vector<int> ret(p.size());
    for (int i = 0; i < p.size(); i++) ret[p[i]] = i;
    return ret;
}
vector<int> operator * (const vector<int>& a, const vector<int>& b ){
    vector<int> ret(a.size());
    for (int i = 0 ; i < a.size(); i++) ret[i] = b[a[i]];
    return ret;
}

struct Group {
    int n, m;
    vector<vector<int>> lookup;
    vector<vector<vector<int>>> buckets, ibuckets;
    int yo(vector<int> p, bool add_to_group = 1){
        n = buckets.size();
        for (int i = 0; i < n ; i++){
            int res = lookup[i][p[i]];
            if (res == -1 ){
                if (add_to_group){
                    buckets[i].push_back(p);
                    ibuckets[i].push_back(inv(p));
                    lookup[i][p[i]] = buckets[i].size() - 1;
                }
                return i;
            }
            p = p * ibuckets[i][res];
        }
        return -1;
    }

    bool in_group(vector<int> g) { return yo(g, false) == -1; }

    Group(vector<vector<int>> &gen, int _n){
        n = _n, m = gen.size(); // m permutations of size n, 0 indexed
        lookup.resize(n);
        buckets.resize(n);
        ibuckets.resize(n);
        for (int i = 0; i < n ; i++){
            lookup[i].resize(n);
            fill(lookup[i].begin(), lookup[i].end(), -1);
        }
        vector<int> id(n);
        for (int i = 0; i < n ; i++) id[i] = i;
        for (int i = 0; i < n ; i++){
            buckets[i].push_back(id);
            ibuckets[i].push_back(id);
            lookup[i][i] = 0;
        }
        for (int i = 0; i < m ; i++) yo(gen[i]);
        queue<pair<pair<int, int>,pair<int, int>>> q;
        for (int i = 0; i < n ; i++) {
            for (int j = i; j < n ; j++) {
                for (int k = 0; k < buckets[i].size(); k++) {
                    for (int l = 0; l < buckets[j].size(); l++) {
                        q.push({pair<int, int>(i, k), pair<int, int>(j, l)});
                    }
                }
            }
        }
        while(!q.empty()) {
            pair<int, int> a = q.front().first;
            pair<int, int> b = q.front().second;
            q.pop();
            int res = yo(buckets[a.first][a.second] * buckets[b.first][b.second]);
            if (res == -1) continue;
            pair<int, int> cur(res, (int)buckets[res].size() - 1);
            for (int i = 0; i < n; i ++) {
                for (int j = 0; j < (int)buckets[i].size(); ++j){
                    if (i <= res) q.push(make_pair(pair<int, int>(i , j), cur));
                    if (res <= i) q.push(make_pair(cur, pair<int, int>(i, j)));
                }
            }
        }
    }
};

const int mod = 998244353;

template<typename T>
T add(T x) {
    return x;
}
template<typename T, typename... Ts>
T add(T x, Ts... y) {
    T res = x + add(y...);
    if (res >= mod)
        res -= mod;
    return res;
}
template<typename T, typename... Ts>
T sub(T x, Ts... y) {
    return add(x, mod - add(y...));
}
template<typename T, typename... Ts>
void udd(T &x, Ts... y) {
    x = add(x, y...);
}
template<typename T>
T mul(T x) {
    return x;
}
template<typename T, typename... Ts>
T mul(T x, Ts... y) {
    return (x * 1ll * mul(y...)) % mod;
}
template<typename T, typename... Ts>
void uul(T &x, Ts... y) {
    x = mul(x, y...);
}
int bin(int a, i64 deg) {
    int r = 1;
    while (deg) {
        if (deg & 1)
            uul(r, a);
        deg >>= 1;
        uul(a, a);
    }
    return r;
}
int inv(int x) {
    assert(x);
    return bin(x, mod - 2);
}

const int maxn = 35;

int dp[maxn][maxn][maxn];

int calc(int n, const Group &g, int a, int b) {
    assert(a < b);
    memset(dp, 0, sizeof(dp));
    dp[0][a][b] = 1;
    for (int i = 0; i < n; ++i) {
        for (int pa = 0; pa < n; ++pa) {
            for (int pb = 0; pb < n; ++pb) {
                if (pa == pb) continue;
                if (dp[i][pa][pb] == 0) continue;
                for (const auto &p: g.ibuckets[i]) {
                    int new_pa = p[pa];
                    int new_pb = p[pb];
                    udd(dp[i + 1][new_pa][new_pb], dp[i][pa][pb]);
                }
            }
        }
    }
    int res = 0;
    for (int pa = 0; pa < n; ++pa) {
        for (int pb = 0; pb < n; ++pb) {
            if (pa <= pb) continue;
            udd(res, dp[n][pa][pb]);
        }
    }
    // cerr << a << " " << b << " " << res << endl;
    return res;
}

// vector<perm> all_perms;

// void rec(int i, int n, vector<int> cur, const Group &g) {
//     if (i == n) {
//         all_perms.push_back(perm(n));
//         return;
//     }
//     for (const auto &p: g.buckets[i]) {
//         perm new_cur = cur * p;
//         rec(i + 1, n, g);
//     }
// }

// int dummy_calc(int a, int b) {

// }

void solve() {
    int n, m;
    cin >> n >> m;
    vector<perm> perms(m, perm(n));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> perms[i][j];
            perms[i][j]--;
        }
    }
    Group g(perms, n);
    // cerr << g.buckets.size() << endl;
    // for (int i = 0; i < g.buckets.size(); i++) {
    //     cerr << "G_" << i << ":" << endl;
    //     for (const auto &p: g.buckets[i]) {
    //         for (int x: p) {
    //             cerr << x << " ";
    //         }
    //         cerr << endl;
    //     }
    //     cerr << "-----------------" << endl;
    // }

    int ans = 0;
    for (int a = 0; a < n; ++a) {
        for (int b = a + 1; b < n; ++b) {
            udd(ans, calc(n, g, a, b));
        }
    }
    cout << ans << "\n";
}

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    int t = 1;
    // cin >> t;
    for (int i = 0; i < t; i++) {
        solve();
    }
}