// Author   : Jakub Rożek
// Task     : Grupa permutacji
// Contest  : PA 2024 r2 A
// Memory   : O(n! * n)
// Time     : O(n! * n^2)
// Solution : dla k=1 działa w n^2

#include "bits/stdc++.h"
using namespace std;
using LL = long long;
template <typename T>
using P = pair<T, T>;
template <typename T>
using VV = vector<vector<T>>;
#define all(x) x.begin(), x.end()
#define FOR(i,a,b) for(int i=(a); i<=(b); ++i)
#define FORD(i,a,b) for(int i=(a); i>=(b); --i)
#define REP(i,n) for(int i=0; i<(n); ++i)
#define ssize(x) int((x).size())
#ifdef DEBUG
template <typename T1, typename T2>
auto&operator<<(auto&o,pair<T1,T2>p){return o<<'('<<p.first<<", "<<p.second<<")";}
auto operator<<(auto&o,auto x)->decltype(x.end(),o){o<<"{";for(auto e:x)o<<e<<",";return o<<"}";}
#define debug(x...) cerr<<"["#x"]: ",[](auto...$){((cerr<<$<<"; "),...)<<endl;}(x)
#else
#define debug(...) {}
#endif

using Per = vector <int>;

// const int INF = 1'000'000'009;
const int MOD = 1'000'000'007;
const int N = 3'000;

struct SegmentTree {
    int R = 1;
    vector<int> tree;

    SegmentTree(LL n) {
        while (R < n) R *= 2;
        tree.resize(2*R, 0);
    }

    void set(int w, int v=1) {
        w += R;
        tree[w] = v;
        while (w) {
            w /= 2;
            tree[w] = tree[w*2] + tree[w*2+1];
        }
    }

    int query(LL c, LL d, int w=1, int a=0, int b=-1) {
        if (b == -1) b += R;
        if (a > d || b < c) return 0;
        if (a >= c && b <= d) return tree[w];
        return query(c, d, w*2, a, (a+b)/2) + query(c, d, w*2+1, (a+b)/2+1, b);
    }
};

LL n, k, x, y, xx, yy, ile_permutacji, ile_inwersji;
Per p, pp;
set <Per> zbior, zbior_startowy;
queue <Per> kolejka;
//k1
LL wartosc[N][N];
bool odw[N];

LL pot(LL a, LL b) {
    LL w = 1;
    while (b) {
        if (b % 2) w = (w * a) % MOD;
        a = (a * a) % MOD;
        b /= 2;
    }
    return w;
}

LL nwd(LL a, LL b) {
    while (a && b) {
        if (a > b) a %= b;
        else b %= a;
    }
    return a + b;
}

LL inwersje(Per a) {
    LL w = 0;
    SegmentTree st(n);
    REP (i, n) {
        w += st.query(a[i], n);
        st.set(a[i]);
    }
    return w;
}

void mnoz(Per &a, Per &b) {
    REP (i, n) {
        p[i] = a[b[i]];
    }
    return;
}

void k_1() {
    ile_permutacji = 1;
    REP (i, n) {
        if (odw[i]) continue;
        x = i;
        y = 0;
        while (odw[x] == 0) {
            odw[x] = 1;
            ++y;
            x = pp[x];
        }
        x = nwd(ile_permutacji, y);
        ile_permutacji *= y/x;
        ile_permutacji %= MOD;
    }

    LL dlug, wyn, wyn2;
    REP (i, n) {
        REP (j,n) {
            wartosc[i][j] = -1;
        }
    }

    FOR (i, 0, n-1) {
        FOR (j, i+1, n-1) {
            if (wartosc[i][j] != -1) continue;
            x = i;
            y = j;
            xx = x;
            yy = y;
            wyn = 0;
            wyn2 = 0;
            do {
                if (x < y) ++wyn;
                else ++wyn2;
                x = pp[x];
                y = pp[y];
            } while (x != xx || y != yy);
            dlug = wyn + wyn2;
            wyn *= ile_permutacji;
            wyn2 *= ile_permutacji;
            wyn %= MOD;
            wyn2 %= MOD;
            wyn *= pot(dlug, MOD-2);
            wyn2 *= pot(dlug, MOD-2);
            wyn %= MOD;
            wyn2 %= MOD;
            do {
                wartosc[x][y] = wyn;
                wartosc[y][x] = wyn2;
                x = pp[x];
                y = pp[y];
            } while (x != xx || y != yy);
        }
    }

    ile_inwersji = 0;
    REP (i, n) {
        REP (j,n) {
            if (pp[i] > pp[j]) {
                ile_inwersji += wartosc[i][j];
                ile_inwersji %= MOD;
            }
        }
    }

}

void difrent() {
    while (!kolejka.empty()) {
        pp = kolejka.front();
        kolejka.pop();
        for (auto i:zbior_startowy) {
            mnoz(i, pp);
            if (zbior.count(p)) continue;
            zbior.insert(p);
            kolejka.push(p);
        }
    }

    ile_inwersji = 0;
    for (auto i:zbior) {
        ile_inwersji += inwersje(i);
        ile_inwersji %= MOD;
    }
    ile_permutacji = ssize(zbior);
}

void solution() {
    cin >> n >> k;
    p.resize(n);
    pp.resize(n);

    REP (i, k) {
        REP (j, n) {
            cin >> p[j];
            --p[j];
        }
        zbior.insert(p);
        zbior_startowy.insert(p);
        kolejka.push(p);
    }

    if (ssize(zbior_startowy) == 1) {
        pp = kolejka.front();
        k_1();
    }
    else {
        difrent();
    }

    ile_inwersji *= pot(ile_permutacji, MOD-2);
    ile_inwersji %= MOD;
    cout << ile_inwersji << '\n';
}

int main() {
    cin.tie(0)->sync_with_stdio(0);
    int tests = 1;
    // cin>>tests;
    FOR (i, 1, tests) {
        solution();
    }
    return 0;
}