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>
using namespace std;
template <typename Iter>
ostream& outIt(ostream& out, Iter b, Iter e) {
  for (Iter i = b; i != e; i++) out << *i << " ";
  return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> v) {
  return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T, size_t N>
ostream& operator<<(ostream& out, array<T, N> v) {
  return outIt(out << '[', (v).begin(), (v).end()) << ']';
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
  return out << '(' << p.first << ", " << p.second << ')';
}
vector<string> v;
vector<vector<int64_t>> bell;
vector<int64_t> dsu, sz;
int64_t root(int64_t i) { return i == dsu[i] ? i : dsu[i] = root(dsu[i]); }
bool join(int64_t i, int64_t j) {
  i = root(i), j = root(j);
  if (i == j) return 0;
  if (sz[i] > sz[j]) swap(i, j);
  sz[j] += sz[i];
  return dsu[i] = j, 1;
}
const int64_t mod = 1000000007;
int64_t p2(int64_t i) {
  int64_t ans = 1, p = 2;
  do
    if (i & 1) ans = (int64_t)ans * p % mod;
  while (p = p * p % mod, i >>= 1);
  return ans;
}
signed main() {
  int64_t m, n;
  cin >> m >> n;
  bell.resize(m + 1);
  for (auto& i : bell) i.resize(m + 1);
  bell[0][0] = 1;
  for (int64_t i = 1; i <= m; i++)
    for (int64_t j = 0; j <= i; j++)
      bell[i][j] =
          j ? (bell[i - 1][j - 1] + bell[i][j - 1]) % mod : bell[i - 1][i - 1];
  v.resize(n);
  dsu.resize(m);
  iota((dsu).begin(), (dsu).end(), 0);
  sz.resize(m, 1);
  for (int64_t i = 0; i < n; i++) {
    cin >> v[i];
  }
  int64_t c = 0;
  for (int64_t i = 0; i < m; i++)
    for (int64_t j = 0; j < m; j++)
      for (int64_t k = 0; k <= n; k++)
        if (k == n)
          c += join(i, j);
        else if (v[k][i] != v[k][j])
          break;
  int64_t ans = 1;
  for (int64_t i = 0; i < m; i++)
    if (dsu[i] == i) ans = ans * bell[sz[i]][0] % mod;
  cout << ans << endl;
}
