package main

import (
	"fmt"
)

const MOD int64 = 1000000007

func mul(A, B [][]int64) [][]int64 {
	size := len(A)
	C := make([][]int64, size)
	for i := range C {
		C[i] = make([]int64, size)
		for k := 0; k < size; k++ {
			if A[i][k] == 0 {
				continue
			}
			for j := 0; j < size; j++ {
				C[i][j] = (C[i][j] + A[i][k]*B[k][j]) % MOD
			}
		}
	}
	return C
}

func pow(A [][]int64, p int64) [][]int64 {
	size := len(A)
	res := make([][]int64, size)
	for i := range res {
		res[i] = make([]int64, size)
		res[i][i] = 1
	}
	base := A
	for p > 0 {
		if p%2 == 1 {
			res = mul(res, base)
		}
		base = mul(base, base)
		p /= 2
	}
	return res
}

func powerP(base, p int64) int64 {
	res := int64(1)
	base %= MOD
	if base < 0 {
		base += MOD
	}
	for p > 0 {
		if p%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		p /= 2
	}
	return res
}

func modInverse(n int64) int64 {
	return powerP(n, MOD-2)
}

func main() {
	var n, k int64
	if _, err := fmt.Scan(&n, &k); err != nil {
		return
	}

	a := make([]int, n)
	c := int64(0)
	for i := int64(0); i < n; i++ {
		fmt.Scan(&a[i])
		if a[i] == 0 {
			c++
		}
	}

	x0 := int64(0)
	for i := int64(0); i < c; i++ {
		if a[i] == 0 {
			x0++
		}
	}

	N := (n * (n - 1) / 2) % MOD

	T := make([][]int64, c+1)
	for i := range T {
		T[i] = make([]int64, c+1)
	}

	for x := int64(0); x <= c; x++ {
		up := ((c - x) * (c - x)) % MOD
		if up < 0 {
			up += MOD
		}
		down := (x * (n - 2*c + x)) % MOD
		if down < 0 {
			down += MOD
		}
		same := (N - up - down) % MOD
		if same < 0 {
			same += MOD
		}

		T[x][x] = same
		if x+1 <= c {
			T[x+1][x] = up
		}
		if x-1 >= 0 {
			T[x-1][x] = down
		}
	}

	Tk := pow(T, k)
	ans := Tk[c][x0]

	invNk := modInverse(powerP(N, k))
	finalAns := (ans * invNk) % MOD

	fmt.Println(finalAns)
}