#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ull = unsigned long long;
using ld = long double;

template<class T>
bool chmin(T &a, T b) {
    if(a <= b) return false;
    a = b;
    return true;
}

template<class T>
bool chmax(T &a, T b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;


template <ll m> struct modint {
    using mint = modint;
    ll a;
    modint(ll x = 0) : a((x%m+m)%m) {}
    static ll mod() {return m;}
    ll & val() {return a;}
    mint pow(ll n){
        mint res = 1;
        mint x = a;
        while(n){
            if (n & 1) res *= x;
            x *= x;
            n >>= 1;
        }
        return res;
    }
    mint inv(){return pow(m-2);}
    mint& operator+=(const mint rhs){
        a+=rhs.a;
        if(a>=m)a-=m;
        return *this;
    }
    mint& operator-=(const mint rhs){
        if (a < rhs.a) a+= m;
        a -= rhs.a;
        return *this;
    }
    mint& operator*=(const mint rhs){
        a = a * rhs.a % m;
        return *this;
    }
    mint & operator/=(mint rhs){
        *this *= rhs.inv();
        return *this;
    }
    friend mint operator+(const mint& lhs, const mint& rhs){
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs){
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs){
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs){
        return mint(lhs) /= rhs;
    }
    mint operator+() const{
        return *this;
    }  
    mint operator-() const{
        return mint() - *this;
    }

};

using modint998244353 = modint<998244353>;
using modint1000000007 = modint<1'000'000'007>;

using mint1 = modint998244353;
using mint2 = modint1000000007;

mint1 base1;
mint2 base2;

void setup(){
    base1 = random_device()();
    base2 = random_device()();
}

ull make_hash(vector<int> &a){
    mint1 hs1 = 0, bs1 = 1;
    mint2 hs2 = 0, bs2 = 1;
    for (auto &x : a){
        hs1 += bs1 * x; bs1 *= base1;
        hs2 += bs2 * x; bs2 *= base2;
    }
    return ((ull)(hs1.val()) << 32) | hs2.val();
}

void solve7(int n, int m){
    vector<vector<int>> ps;
    vector<int> ids(n); iota(all(ids),0);
    do {
        ps.emplace_back(ids);
    }while(next_permutation(all(ids)));
    map<vector<int>,int> mp;
    for (int i = 0; auto v : ps) mp[v] = i++;
    int sz = ps.size();
    vector<bool> dp(sz,false);
    while (m--){
        vector<int> p(n);
        rep(i,0,n) cin >> p[i], p[i]--;
        int id = mp[p];
        vector<bool> ep(sz,false);
        rep(i,0,sz){
            if (!dp[i]) continue;
            ep[i] = true;
            vector<int> pq(n);
            rep(j,0,n) pq[j] = ps[i][p[j]];
            ep[mp[pq]] = true;
        }
        ep[id] = true;
        swap(dp,ep);
    }
    int ans = 0;
    rep(i,0,sz) if (dp[i]) ans++;
    cout << ans << endl;
}

template<typename T, size_t Extent>
vector<pair<vector<int>,int>> half(span<T,Extent> sp, int n, int m){
    vector<pair<vector<int>,int>> cur(1<<m);
    {
        vector<int> ideal(n); iota(all(ideal),0);
        cur[0] = {ideal,0};
    }
    int sz = 1;
    for (int id = 0; auto q : sp){
        rep(i,0,sz){
            auto [p, s] = cur[i];
            vector<int> pq(n);
            rep(j,0,n) pq[j] = p[q[j]];
            int ns = s | (1<<id);
            cur[sz+i] = {pq,ns};
        }
        sz <<= 1;
        id++;
    }
    return cur;
}

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a){
    const char* delim = "";
    for (auto &x : a){
        os << exchange(delim," ") << x;
    }
    return os;
}

void solve8(int n, int m){
    setup();
    int h = m/2;
    vector<vector<int>> a(m,vector<int>(n));
    rep(i,0,m) rep(j,0,n) cin >> a[i][j], a[i][j]--;
    auto le = half(span{a.begin(),a.begin()+h},n,h);
    auto ri = half(span{a.begin()+h,a.end()},n,m-h);
    // for (auto [p, ps] : le){
    //     cout << p << " : " << ps << endl;
    // }
    // cout << endl;
    // for (auto [q, qs] : ri){
    //     cout << q << " : " << qs << endl;
    // }
    unordered_set<ull> st;
    for (auto [p, ps] : le) for (auto [q, qs] : ri){
        if (ps == 0 && qs == 0) continue;
        vector<int> pq(n);
        rep(i,0,n) pq[i] = p[q[i]];
        auto hs = make_hash(pq);
        st.insert(hs);
    }
    cout << st.size() << endl;
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n, m; cin >> n >> m;
    if (n <= 7){
        solve7(n,m);
    }
    else {
        solve8(n,m);
    }
}