package main

import (
	"fmt"
	"io"
	"os"
)

const MOD int64 = 1000000007

func modPow(a, e int64) int64 {
	r := int64(1)
	for e > 0 {
		if e&1 == 1 {
			r = r * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return r
}

func isLucky(x int) bool {
	for x > 0 {
		d := x % 10
		if d != 4 && d != 7 {
			return false
		}
		x /= 10
	}
	return true
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int {
		for p < len(data) && (data[p] < '0' || data[p] > '9') {
			p++
		}
		v := 0
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			v = v*10 + int(data[p]-'0')
			p++
		}
		return v
	}

	n := nextInt()
	k := nextInt()

	cnt := make(map[int]int)
	unlucky := 0
	for i := 0; i < n; i++ {
		x := nextInt()
		if isLucky(x) {
			cnt[x]++
		} else {
			unlucky++
		}
	}

	fact := make([]int64, n+1)
	invFact := make([]int64, n+1)
	fact[0] = 1
	for i := 1; i <= n; i++ {
		fact[i] = fact[i-1] * int64(i) % MOD
	}
	invFact[n] = modPow(fact[n], MOD-2)
	for i := n; i > 0; i-- {
		invFact[i-1] = invFact[i] * int64(i) % MOD
	}

	comb := func(nn, rr int) int64 {
		if rr < 0 || rr > nn {
			return 0
		}
		return fact[nn] * invFact[rr] % MOD * invFact[nn-rr] % MOD
	}

	limit := k
	if len(cnt) < limit {
		limit = len(cnt)
	}

	dp := make([]int64, limit+1)
	dp[0] = 1
	used := 0
	for _, c := range cnt {
		used++
		up := used
		if up > limit {
			up = limit
		}
		for j := up; j >= 1; j-- {
			dp[j] = (dp[j] + dp[j-1]*int64(c)) % MOD
		}
	}

	ans := int64(0)
	for t := 0; t <= limit; t++ {
		ans = (ans + dp[t]*comb(unlucky, k-t)) % MOD
	}

	fmt.Println(ans)
}