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 comment(linker, "/STACK:2010886400")
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000001;
const long double EPS = 1e-9;
const int HASH_POW = 29;
const long double PI = acos(-1.0);
mt19937_64 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
long long nextLong(long long l, long long r) {
  uniform_int_distribution<long long> foo(l, r);
  return foo(rnd);
}
double nextDouble(double l, double r) {
  uniform_real_distribution<double> foo(l, r);
  return foo(rnd);
}
double workTime() { return double(clock()) / CLOCKS_PER_SEC; }
void myReturn(int code = 0) { exit(code); }
int binPow(int a, int n) {
  int ans = 1;
  while (n) {
    if (n & 1) {
      ans = ans * 1ll * a % MOD;
    }
    n >>= 1;
    a = a * 1ll * a % MOD;
  }
  return ans;
}
int dp[1010][1010], sum[1010];
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<vector<int> > p;
  vector<int> foo;
  for (int i = 0; i < n; ++i) {
    foo.push_back(i);
  }
  p.push_back(foo);
  for (int i = 0; i < m; ++i) {
    string s;
    cin >> s;
    vector<vector<int> > q;
    for (int id = 0; id < p.size(); ++id) {
      vector<int> a, b;
      for (int j = 0; j < p[id].size(); ++j) {
        if (s[p[id][j]] == '0') {
          a.push_back(p[id][j]);
        } else {
          b.push_back(p[id][j]);
        }
      }
      if (!a.empty()) {
        q.push_back(a);
      }
      if (!b.empty()) {
        q.push_back(b);
      }
    }
    p = q;
  }
  dp[0][0] = 1;
  for (int i = 1; i <= 1000; ++i) {
    for (int j = 1; j <= 1000; ++j) {
      dp[i][j] = (dp[i - 1][j] * 1ll * j + dp[i - 1][j - 1]) % MOD;
    }
    for (int j = 0; j <= 1000; ++j) {
      sum[i] = (sum[i] + dp[i][j]) % MOD;
    }
  }
  int ans = 1;
  for (int i = 0; i < p.size(); ++i) {
    ans = ans * 1ll * sum[p[i].size()] % MOD;
  }
  cout << ans << endl;
  myReturn();
}
