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;
const long long MOD = (long long)1e9 + 7;
class modint {
  int v;

 public:
  modint() : v(0) {}
  modint(long long v) : v((v + MOD) % MOD) {}
  bool operator==(modint x) { return v == x.v; }
  bool operator!=(modint x) { return v != x.v; }
  modint operator+(modint x) { return v + x.v; }
  modint operator-(modint x) { return v - x.v; }
  modint operator*(modint x) { return (long long)v * x.v; }
  modint operator/(modint x) { return *this * x.inv(); }
  modint& operator+=(const modint x) { return *this = (*this + x); }
  modint& operator-=(const modint x) { return *this = (*this - x); }
  modint& operator*=(const modint x) { return *this = (*this * x); }
  modint& operator/=(const modint x) { return *this = (*this / x); }
  int operator*() { return v; }
  modint inv() {
    modint ret = 1, cur = v;
    int p = MOD - 2;
    while (p > 0) {
      if (p & 1) ret = ret * cur;
      cur = cur * cur;
      p >>= 1;
    }
    return ret;
  }
};
const int N_ = 55, M_ = 1050;
int M, N;
char T[N_][M_];
char tmp[M_];
modint S[M_][M_], bell[M_];
int _grp[M_];
int grp(int x) { return x == _grp[x] ? x : (_grp[x] = grp(_grp[x])); }
int main() {
  scanf("%d%d", &M, &N);
  for (int i = 1; i <= N; i++) {
    scanf("%s", T[i]);
  }
  for (int b = 0; b < M; b++) {
    _grp[b] = b;
  }
  for (int p = 0; p < M; p++) {
    for (int q = p + 1; q < M; q++) {
      bool good = true;
      for (int i = 1; i <= N; i++) {
        good &= (T[i][p] == T[i][q]);
      }
      if (good) {
        int x = grp(p), y = grp(q);
        _grp[x] = y;
      }
    }
  }
  map<int, int> freq;
  for (int b = 0; b < M; b++) {
    freq[grp(b)] += 1;
  }
  S[0][0] = 1;
  bell[0] = 1;
  for (int i = 1; i <= M; i++) {
    for (int j = 1; j <= i; j++) {
      S[i][j] = S[i - 1][j - 1] + S[i - 1][j] * j;
      bell[i] += S[i][j];
    }
  }
  modint ans = 1;
  for (auto it : freq) {
    ans *= bell[it.second];
  }
  printf("%d\n", *ans);
  return 0;
}
