#include <bits/stdc++.h>

using namespace std;

#if __cplusplus >= 201103L
    struct pairhash {
        static uint64_t splitmix64(uint64_t x) {
            x += 0x9e3779b97f4a7c15;
            x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
            x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
            return x ^ (x >> 31);
        }

        template<class T, class U>
        size_t operator() (const pair<T,U> &p) const {
            static const uint64_t FIXED_RANDOM = (uint64_t)chrono::steady_clock::now().time_since_epoch().count();
            return splitmix64(p.first + FIXED_RANDOM) ^ splitmix64(p.second+ FIXED_RANDOM);
        }
    };
    struct custom_hash {
        static uint64_t splitmix64(uint64_t x) {
            x += 0x9e3779b97f4a7c15;
            x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
            x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
            return x ^ (x >> 31);
        }

        size_t operator()(uint64_t x) const {
            static const uint64_t FIXED_RANDOM = (uint64_t)chrono::steady_clock::now().time_since_epoch().count();
            return splitmix64(x + FIXED_RANDOM);
        }
    };
    mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
    inline int randint(int l, int r) {
        return uniform_int_distribution<int>(l,r)(rng);
    }
    inline double randdouble(double l, double r) {
        return uniform_real_distribution<double>(l,r)(rng);
    }
#endif
 
#ifndef ONLINE_JUDGE
#  define LOG(x) (cerr << #x << " = " << (x) << endl)
#else
#  define LOG(x) 0
#endif

#define fastio ios::sync_with_stdio(false); cin.tie(0);
#define ll long long
#define ull unsigned long long
#define ll128 __int128_t
#define PI 3.14159265358979323846
#define abs(a) ((a>0)?a:-(a))
#define pii pair<int,int>
#define pll pair<ll,ll>

const long double pi = acos(-1.0);
const long double eps = (double)1e-8;

const int mod = 1e9+7;

template<class T>
T qpow(T a, int b) {
    T res = 1;
    while (b) {
        if (b & 1) res *= a;
        a *= a;
        b >>= 1;
    }
    return res;
}
int norm(int x) {
    if (x < 0) {
        x += mod;
    }
    if (x >= mod) {
        x -= mod;
    }
    return x;
}
struct Z {
    int x;
    Z(int x = 0) : x(norm(x)) {}
    Z(ll x) : x(norm((int)(x % mod))) {}
    int val() const {
        return x;
    }
    Z operator-() const {
        return Z(norm(mod - x));
    }
    Z inv() const {
        assert(x != 0);
        return qpow(*this, mod - 2);
    }
    Z &operator*=(const Z &rhs) {
        x = (ll)(x) * rhs.x % mod;
        return *this;
    }
    Z &operator+=(const Z &rhs) {
        x = norm(x + rhs.x);
        return *this;
    }
    Z &operator-=(const Z &rhs) {
        x = norm(x - rhs.x);
        return *this;
    }
    Z &operator/=(const Z &rhs) {
        return *this *= rhs.inv();
    }
    friend Z operator*(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res *= rhs;
        return res;
    }
    friend Z operator+(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res += rhs;
        return res;
    }
    friend Z operator-(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res -= rhs;
        return res;
    }
    friend Z operator/(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Z &a) {
        ll v;
        is >> v;
        a = Z(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Z &a) {
        return os << a.val();
    }
};

const int maxn = 1e5+5;
const int maxm = 2e5+55;


int n, m, a[21][21];
int ok[21][21];
bool good[21];
ll ans = 0;
int dp[21];
vector<pii> adj[(1<<20)+5];

inline void solve(int mask) {

    memset(good, 1, sizeof(good));
    memset(dp, 0, sizeof(dp));
    vector<int> vec;

    for (int i = 1; i <= n; i++) {
        vec.clear();

        for (int j = 1; j <= m; j++) {
            if (mask&(1<<(j-1))) vec.push_back(a[i][j]);
        }
        // 看vec是否单调
        if (vec.size() == 1) {
            continue;
        }

        bool inc = (vec[1] > vec[0]);
        for (int j = 1; j < vec.size(); j++) {
            if (inc && vec[j] < vec[j-1]) good[i] = 0;
            if (!inc && vec[j] > vec[j-1]) good[i] = 0;
        }
    }

    vector<int> goods;
    for (int i = 1; i <= n; i++) {
        if (good[i]) goods.push_back(i);
    }

    vector<int> tmp;

    ans += goods.size();

    for (int ii = 0; ii < goods.size(); ii++) {
        for (int jj = ii+1; jj < goods.size(); jj++) {
            int i = goods[ii], j = goods[jj];
            int nm = (mask & ok[i][j]);
            // 1: < , 0 : >
            adj[nm].push_back({i,j});

            tmp.push_back(nm);
        }
    }
    sort(tmp.begin(), tmp.end());
    tmp.resize(unique(tmp.begin(), tmp.end()) - tmp.begin());

    for (int nm : tmp) {
        // int sum = 0;
        for (pii p : adj[nm]) {
            dp[p.second] += dp[p.first] + 1;
            ans += dp[p.first] + 1;
            // sum += dp[p.first] + 1;
        }
        for (pii p : adj[nm]) {
            dp[p.first] = dp[p.second] = 0;
        }
        // printf("nm = %d, sum = %d, mask = %d\n",nm,sum,mask);
    }

    for (int nm : tmp) {
        adj[nm].clear();
    }


    // if ((mask & ok[i][j]) == mask)

    // for (int i = 1; i <= n; i++) {
    //     if (!good[i]) continue;
    //     dp[i] = 1;
    //     for (int j = i-1; j >= 1; j--) {
    //         if (!good[j]) continue;
    //         if ((mask & ok[j][i]) == mask) {
    //             dp[i] = max(dp[i], dp[j] + 1);
    //             // LOG(i);
    //             // LOG(dp[i]);
    //             // LOG(dp[i-1]);
    //         }
    //     }
    //     ans += (1<<(dp[i]-1));
    // }
}

int main() {
    fastio;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) cin >> a[i][j];
    }

    for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            for (int k = 1; k <= m; k++) {
                if (a[i][k] <= a[j][k]) ok[i][j] |= (1<<(k-1));
            }
        }
    }

    for (int mask = 1; mask < (1<<m); mask++) {
        solve(mask);
    }
    cout << ans << endl;
}