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}.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class NewYearEntityEnumeration {
    
    int N = 1005;
    int MOD = (int) 1e9 + 7;
    
    int[][] comb = new int[N][N];
    int[] bell = new int[N];
    
    {
        for (int i = 0; i < N; i++) {
            comb[i][0] = 1;
            for (int j = 1; j <= i; j++) comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % MOD;
        }
        
        bell[0] = 1;
        for (int i = 1; i < N; i++) {
            for (int j = 0; j < i; j++) {
                bell[i] = (int) ((bell[i] + (long) comb[i - 1][j] * bell[j]) % MOD);
            }
        }
    }
    
    void solve() {
        int m = in.nextInt(), n = in.nextInt();
        char[][] s = new char[n][];
        for (int i = 0; i < n; i++) s[i] = in.nextToken().toCharArray();
        
        long[] code = new long[m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                code[j] |= (long) (s[i][j] - '0') << i;
            }
        }
        Arrays.sort(code);
        
        long ans = 1;
        for (int i = 0; i < m; ) {
            int j = i;
            while (j < m && code[j] == code[i]) j++;
            ans = ans * bell[j - i] % MOD;
            i = j;
        }
        out.println(ans);
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new NewYearEntityEnumeration().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
