#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()


const int MAXN = 180;

int A[MAXN][MAXN];
int cur[MAXN][MAXN];
int n, m;


int trie_go[(1 << 20) * 9 * 9 + 228];
int nodes_cnt = 0;

int trie_node() {
    fill(trie_go + nodes_cnt * n, trie_go + nodes_cnt * n + n, -1);
    ++nodes_cnt;
    return nodes_cnt - 1;
}

int ans = 0;

void go(int i, int mask) {
    if (i == m) {
        if (mask) {
            // add cur[i]
            int cur_node = 0;
            bool is_new = false;
            for (int j = 0; j < n; ++j) {
                if (trie_go[cur_node * n + cur[i][j]] == -1) {
                    is_new = true;
                    trie_go[cur_node * n + cur[i][j]] = trie_node();
                }
                cur_node = trie_go[cur_node * n + cur[i][j]];
            }
            if (is_new)
                ++ans;
        }
        return;
    }
    // not take i
    for (int j = 0; j < n; ++j) {
        cur[i + 1][j] = cur[i][j];
    }
    go(i + 1, mask);
    // take i
    for (int j = 0; j < n; ++j) {
        cur[i + 1][j] = cur[i][A[i][j]];
    }
    go(i + 1, mask | (1 << i));
}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> m;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> A[i][j];
            --A[i][j];
        }
        //iota(A[i], A[i] + n, 0);
        //random_shuffle(A[i], A[i] + n);
    }


    if (m <= 20) {
        trie_node();
        iota(cur[0], cur[0] + n, 0);
        go(0, 0);
        cout << ans << '\n';
    } else {
        vector<int> facts(n + 1);
        facts[0] = 1;
        for (int i = 1; i <= n; ++i)
            facts[i] = facts[i - 1] * i;
        auto get_ind = [&](vector<int>& cur) {
            for (int i = 0; i < n; ++i) {
                for (int j = i + 1; j < n; ++j) {
                    if (cur[j] > cur[i])
                        --cur[j];
                }
            }
            int ans = 0;
            for (int i = 0; i < n; ++i)
                ans += facts[n - i - 1] * cur[i];
            return ans;
        };
        vector<bool> dp(facts[n], false);
        vector<bool> new_dp(facts[n], false);
        for (int i = 0; i < m; ++i) {
            fill(new_dp.begin(), new_dp.end(), false);
            vector<int> cur(n);
            iota(cur.begin(), cur.end(), 0);
            vector<int> cur2(n);
            int id = 0;
            while (true) {
                if (dp[id]) {
                    new_dp[id] = true;
                }
                if (dp[id] || id == 0) {
                    for (int j = 0; j < n; ++j)
                        cur2[j] = cur[A[i][j]];
                    int nxt_id = get_ind(cur2);
                    new_dp[nxt_id] = true;
                }
                ++id;
                if (!next_permutation(cur.begin(), cur.end()))
                    break;
            }
            swap(dp, new_dp);
        }
        int ans = 0;
        for (bool b : dp)
            ans += b;
        cout << ans << '\n';
    }

    //cerr << clock() * 1.0 / CLOCKS_PER_SEC << '\n';
    return 0;
}