MOD = 10**9 + 7

def main():
    import sys
    input = sys.stdin.read().split()
    ptr = 0
    N = int(input[ptr])
    ptr += 1
    k = int(input[ptr])
    ptr += 1
    a = []
    if k > 0:
        a = list(map(int, input[ptr:ptr + k]))
    
    # Precompute factorials modulo MOD up to N
    max_n = N
    factorial = [1] * (max_n + 1)
    for i in range(1, max_n + 1):
        factorial[i] = factorial[i-1] * i % MOD
    
    if k == 0:
        print(factorial[N] % MOD)
        return
    
    # Process a_i's
    masks = []
    for num in a:
        mask = num
        bit_count = bin(mask).count('1')
        masks.append((bit_count, mask))
    
    # Check if all masks have unique bit counts
    seen = set()
    for cnt, _ in masks:
        if cnt in seen:
            print(0)
            return
        seen.add(cnt)
    
    # Sort by bit count
    masks.sort()
    bit_counts = [cnt for cnt, _ in masks]
    masks_sorted = [mask for _, mask in masks]
    # Check if the sorted masks form a chain of subsets
    for i in range(1, len(masks_sorted)):
        prev_mask = masks_sorted[i-1]
        current_mask = masks_sorted[i]
        if (prev_mask & current_mask) != prev_mask:
            print(0)
            return
    
    # Compute the parts (segments)
    parts = []
    prev_bit_count = 0
    for cnt, mask in masks:
        part = cnt - prev_bit_count
        if part <= 0:
            print(0)
            return
        parts.append(part)
        prev_bit_count = cnt
    
    # Remaining bits after the last mask
    last_bit_count = prev_bit_count
    rem = N - last_bit_count
    if rem < 0:
        print(0)
        return
    parts.append(rem)
    
    # Compute the product of factorials of each part
    result = 1
    for p in parts:
        result = result * factorial[p] % MOD
    
    print(result % MOD)

if __name__ == '__main__':
    main()