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.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class cf908E {
	final int MOD = 1_000_000_007;
	
	public static void main(String[] argv) throws FileNotFoundException {
		cf908E problem = new cf908E();
		
		InputStream fin;
		if (System.getProperty("ONLINE_JUDGE") != null) {
			fin = System.in;
		} else {
			fin = new FileInputStream("input.txt");
		}
		problem.solve(new Scanner(fin), System.out);
	}

	private void solve(Scanner scanner, PrintStream out) {
		int m = scanner.nextInt();
		int n = scanner.nextInt();
		String t[] = new String[n];
		for (int i = 0; i < n; i++) {
			t[i] = scanner.next();
		}
		
		long f[][] = new long[m + 1][m + 1];
		for (int i = 1; i <= m; i++) {
			for (int j = 1; j <= i; j++) {
				if (i == 1) {
					f[i][j] = 1;
				} else {
					f[i][j] = (f[i - 1][j] * j + f[i - 1][j - 1]) % MOD;
				}
			}
		}
		
		long ans = 1;
		ArrayList<Integer> list = computeG(m, t);
		for (Integer num : list) {
			long acc = 0;
			for (int j = 1; j <= num; j++) {
				acc = (acc + f[num][j]) % MOD;
			}
			ans = ans * acc % MOD;
		}
		out.println(ans);
	}

	private ArrayList<Integer> computeG(int m, String[] t) {
		long mask[] = new long[m];
		for (int i = 0; i < t.length; i++) {
			String string = t[i];
			assert m == string.length();
			for (int j = 0; j < m; j++) {
				if (string.charAt(j) == '1') {
					mask[j] |= 1L << i;
				}
			}
		}
		Arrays.sort(mask);
		
		ArrayList<Integer> res = new ArrayList<Integer>();
		for (int i = 0, j; i < mask.length; i = j) {
			j = i + 1;
			while (j < mask.length && mask[i] == mask[j]) {
				j += 1;
			}
			res.add(j - i);
		}
		
		return res;
	}
}