use std::io::*;
use std::str::FromStr;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[allow(dead_code)]
// a x + b y = gcd(a, b)
fn extgcd(a: i64, b: i64, x: &mut i64, y: &mut i64) -> i64 {
    let mut g = a;
    *x = 1;
    *y = 0;
    if b != 0 {
        g = extgcd(b, a % b, y, x);
        *y -= (a / b) * *x;
    }
    g
}

#[allow(dead_code)]
fn pow_mod(base: i64, power: i64, modulo: i64) -> i64 {
    let mut base = base;
    let mut power = power;
    let mut ans = 1;
    while power > 0 {
        if power & 1 == 1 { ans = ans * base % modulo; }
        power >>= 1;
        base = base * base % modulo;
    }
    ans
}

#[allow(dead_code)]
fn inv_mod(a: i64, modulo: i64) -> i64 {
    pow_mod(a, modulo - 2, modulo)
}

const MOD: i64 = 1e+9 as i64 + 7;
const FACT_MAX: usize = 100000;
static mut FACTORIAL: [i64; FACT_MAX + 1] = [0; FACT_MAX + 1];
static mut RFACTORIAL: [i64; FACT_MAX + 1] = [0; FACT_MAX + 1];
#[allow(dead_code)]
fn fact(n: usize) -> i64 {
    unsafe {
        FACTORIAL[n]
    }
}
#[allow(dead_code)]
fn combi(n: usize, m: usize) -> i64 {
    if n < m { return 0; }
    unsafe {
        FACTORIAL[n] * RFACTORIAL[m] % MOD * RFACTORIAL[n - m] % MOD
    }
}

fn calc_rest(n: usize, use_set: usize, v: usize) -> i32 {
    let mut usable = ((1 << n) - v) as i32;
    for i in 0..n {
        if ((use_set >> i) & 1) != 1 { continue; }
        usable -= 1 << i;
    }
    usable
}
fn calc_dp(n: usize, aseq: &Vec<usize>, dp: &mut Vec<Vec<i64>>) {
    let mut cnt_memo = vec![vec![0; n]; 1 << n];
    for i in 0..(1 << n) {
        for j in 0..n {
            cnt_memo[i][j] = combi(i, (1 << j) - 1) * fact(1 << j) % MOD as i64;
        }
    }
    for depth in 0..aseq.len() {
        for use_set in 0..(1 << n) {
            dp[depth + 1][use_set] = (dp[depth + 1][use_set] + dp[depth][use_set]) % MOD;
            let usable = calc_rest(n, use_set, aseq[depth]);
            // println!("{} {} {}", depth, use_set, usable);
            if usable < 0 { continue; }
            for i in 0..n {
                let nuse_set = use_set | (1 << i);
                if use_set == nuse_set { continue; }
                let cnt = cnt_memo[usable as usize][i];
                // let cnt = combi(usable as usize, (1 << i) - 1) * fact(1 << i) % MOD;
                dp[depth + 1][nuse_set] = (dp[depth + 1][nuse_set] + cnt * dp[depth][use_set]) % MOD;
            }
        }
    }
}

fn f(n: usize, use_set: usize) -> i64 {
    let usable = calc_rest(n, use_set, 1) as usize;
    fact(usable) * (1 << n) % MOD
}

fn main() {
    unsafe {
        FACTORIAL[0] = 1;
        RFACTORIAL[0] = 1;
        for i in 1..FACT_MAX+1 {
            FACTORIAL[i] = (FACTORIAL[i - 1] * i as i64) % MOD;
            RFACTORIAL[i] = inv_mod(FACTORIAL[i], MOD);
        }
    }
    let n: usize = read();
    let m: usize = read();
    let mut aseq = vec![0; m];
    for i in 0..m {
        aseq[i] = read();
    }
    aseq.sort();
    aseq.reverse();
    let mut dp = vec![vec![0 as i64; 1 << n]; m + 1];
    dp[0][0] = 1;
    calc_dp(n, &aseq, &mut dp);
    let mut ans = 0 as i64;
    for use_set in 0..(1 << n) {
        let sign = if (use_set as usize).count_ones() % 2 == 0 { 1 } else { -1 };
        // println!("{}", dp[m][use_set]);
        ans = (ans + f(n, use_set) * dp[m][use_set] % MOD * sign + MOD) % MOD;
    }
    println!("{}", ans);
}

Measured memory_bytes: 24316