You are given an integer m.

Let M = 2m - 1.

You are also given a set of n integers denoted as the set T. The integers will be provided in base 2 as n binary strings of length m.

A set of integers S is called "good" if the following hold. 

  1. If <image>, then <image>. 
  2. If <image>, then <image>
  3. <image>
  4. All elements of S are less than or equal to M. 



Here, <image> and <image> refer to the bitwise XOR and bitwise AND operators, respectively.

Count the number of good sets S, modulo 109 + 7.

Input

The first line will contain two integers m and n (1 ≤ m ≤ 1 000, 1 ≤ n ≤ min(2m, 50)).

The next n lines will contain the elements of T. Each line will contain exactly m zeros and ones. Elements of T will be distinct.

Output

Print a single integer, the number of good sets modulo 109 + 7. 

Examples

Input

5 3
11010
00101
11000


Output

4


Input

30 2
010101010101010010101010101010
110110110110110011011011011011


Output

860616440

Note

An example of a valid set S is {00000, 00101, 00010, 00111, 11000, 11010, 11101, 11111}.
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
using namespace std;
const int DEFAULT_MOD = 1e9 + 7;
template <class T, T MOD = DEFAULT_MOD>
struct mod {
  mod() : value(0) {}
  mod(T x) { value = x; }
  T value;
};
template <class T, T MOD>
inline mod<T, MOD> operator+(mod<T, MOD> a, mod<T, MOD> b) {
  mod<T, MOD> result = {a.value + b.value};
  if (result.value > MOD) {
    result.value -= MOD;
  }
  return result;
};
template <class T, T MOD>
inline mod<T, MOD> operator-(mod<T, MOD> a, mod<T, MOD> b) {
  mod<T, MOD> result = {a.value - b.value};
  if (result.value < 0) {
    result.value += MOD;
  }
  return result;
};
template <class T, T MOD>
inline mod<T, MOD> operator*(mod<T, MOD> a, mod<T, MOD> b) {
  return mod<T, MOD>(a.value * 1ll * b.value % MOD);
};
template <class T, T MOD>
inline bool operator<(mod<T, MOD> a, mod<T, MOD> b) {
  return a.value < b.value;
};
template <class T, T MOD>
inline bool operator>(mod<T, MOD> a, mod<T, MOD> b) {
  return a.value > b.value;
};
template <class T, T MOD>
inline mod<T, MOD> power(mod<T, MOD> a, mod<T, MOD> p) {
  mod<T, MOD> result(1);
  T pp = p.value;
  for (mod<T, MOD> sq = a; pp > 0; pp >>= 1, sq = sq * sq) {
    if (pp & 1) {
      result = result * sq;
    }
  }
  return result;
}
template <class T, T MOD>
inline mod<T, MOD> operator/(mod<T, MOD> a, mod<T, MOD> b) {
  return a * power(b, mod<T, MOD>(MOD - 2));
};
template <class T, T MOD>
ostream &operator<<(ostream &os, const mod<T, MOD> &a) {
  os << a.value;
  return os;
};
template <class T, T MOD>
istream &operator>>(istream &is, mod<T, MOD> &a) {
  is >> a.value;
  return is;
};
struct TaskE {
  void solve(istream &in, ostream &out) {
    int m, n;
    in >> m >> n;
    vector<string> a(n);
    for (int i = 0; i < n; i++) {
      in >> a[i];
    }
    map<string, int> cnt;
    for (int j = 0; j < m; j++) {
      string s;
      for (int i = 0; i < n; i++) {
        s += a[i][j];
      }
      cnt[s]++;
    }
    vector<vector<mod<int>>> dp(m + 1, vector<mod<int>>(m + 1));
    dp[0][0] = 1;
    for (int i = 0; i <= m - 1; i++) {
      for (int j = 0; j < m; j++) {
        dp[i + 1][j] = dp[i + 1][j] + dp[i][j] * mod<int>(j);
        dp[i + 1][j + 1] = dp[i + 1][j + 1] + dp[i][j];
      }
    }
    vector<mod<int>> d(m + 1);
    for (int i = 0; i <= m; i++) {
      for (int j = 0; j <= m; j++) {
        d[i] = d[i] + dp[i][j];
      }
    }
    mod<int> result = 1;
    for (auto p : cnt) {
      int x = p.second;
      result = result * d[x];
    }
    out << result << endl;
  }
};
int main() {
  ios_base::sync_with_stdio(0);
  cout.precision(30);
  cout << fixed;
  TaskE solver;
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  solver.solve(in, out);
  return 0;
}
