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}.
//package practice.pset1;

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class R908E {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int m = sc.nextInt();
        int n = sc.nextInt();

        char[][] s = new char[n][];
        for (int i = 0; i < n; i++) {
            s[i] = sc.next().toCharArray();
        }

        int[] bell = generateBellNumbers(1004);
        long[] masks = new long[m];
        for (int i = 0; i < m; i++) {
            long msk = 0;
            for (int j = 0; j < n; j++) {
                msk = msk*2 + (s[j][i]-'0');
            }
            masks[i] = msk;
        }

        long ans = 1;
        for (int i = 0; i < masks.length; i++) {
            if(masks[i] == -1)
                continue;
            int cnt = 1;
            for (int j = i+1; j < masks.length; j++) {
                if(masks[i]==masks[j]){
                    masks[j] = -1;
                    cnt++;
                }
            }
            ans = (ans*bell[cnt])%mod;
            masks[i] = -1;
        }

        pw.println(ans);
        pw.flush();
        pw.close();
    }


    static int mod = (int)1e9+7;
    static int[] generateBellNumbers(int n){
        int [][] dp = new int[n+1][n+1];
        dp[0][0] = 1;
        for (int i = 1; i < n; i++)
            for (int j = 0; j < n; j++)
                if(j == 0)
                    dp[i][j] = dp[i-1][i-1];
                else
                    dp[i][j] = (dp[i-1][j-1] + dp[i][j-1])%mod;

        int[] res = new int[n];
        for (int i = 0; i < res.length-1; i++) {
            res[i+1] = dp[i][i];
        }

        res[0] = 1;
        return res;
    }


    static class Scanner
    {
        StringTokenizer st; BufferedReader br;
        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
        public Scanner(String s) throws FileNotFoundException {	br = new BufferedReader(new FileReader(new File(s)));}
        public String next() throws IOException {while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());return st.nextToken();}
        public int nextInt() throws IOException {return Integer.parseInt(next());}
        public long nextLong() throws IOException {return Long.parseLong(next());}
        public String nextLine() throws IOException {return br.readLine();}
        public boolean ready() throws IOException {return br.ready();}
    }
}
