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.*;
import java.util.*;

public class Codeforces908E {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] sp = br.readLine().split(" ");
		//Scanner input = new Scanner(System.in);
		int m = Integer.parseInt(sp[0]);
		int n = Integer.parseInt(sp[1]);
		
		int[] ptr = new int[m];
		for (int i = 1; i < m; i++) {
			ptr[i] = i-1;
		}
		for (int i = 0; i < n; i++) {
			sp = br.readLine().split(" ");
			String s = sp[0];
			//String s = input.next();
			for (int j = m-1; j >= 0; j--) {
				while (s.charAt(j) != s.charAt(ptr[j])) {
					if (ptr[ptr[j]] == ptr[j])
						ptr[j] = j;
					else	
						ptr[j] = ptr[ptr[j]];
				}
			}
		}
		
		for (int i = 0; i < m; i++) {
			while (ptr[i] != ptr[ptr[i]]) {
				ptr[i] = ptr[ptr[i]];
			}
		}
		
		int k = 0;
		for (int i = 0; i < m; i++) {
			if (ptr[i] == i) {
				k++;
			}
		}
		
		int[] a = new int[m];
		int counter = 1;
		for (int i = 0; i < m; i++) {
			if (ptr[i] == i) {
				a[i] = counter;
				counter++;
			}
		}
		
		int[] part = new int[k];
		for (int i = 0; i < m; i++) {
			part[a[ptr[i]]-1]++;
		}
		
		int[][] partition = new int[m+1][m+1];
		partition[1][1] = 1;
		for (int i = 2; i <= m; i++) {
			for (int j = 1; j <= i; j++) {
				partition[i][j] = (partition[i-1][j-1] + multiply(partition[i-1][j], j))%1000000007;
			}
		}
		
		int[] finalpartition = new int[m+1];
		finalpartition[1] = 1;
		for (int i = 2; i <= m; i++) {
			for (int j = 1; j <= i; j++) {
				finalpartition[i] = (finalpartition[i]+partition[i][j])%1000000007;
			}
		}
		
		int ans = 1;
		for (int i = 0; i < k; i++) {
			ans = multiply(ans, finalpartition[part[i]]);
		}
		
		System.out.println(ans);
	}
	
	public static int multiply (int a, int b) {
		long c = (long) a;
		long d = (long) b;
		long e = (c*d)%1000000007;
		return ((int) e);
	}
	
}
