For problem statement at 1000-1999/1500-1599/1570-1579/1575/problemF.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1570-1579/1575/verifierF.go ends with test 1 failed:
input:
3 6
3 3 3 
expected: 42
got: 0
exit status 1 can you fix the verifier? package main

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

const MOD int64 = 1000000007

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	b, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: b}
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	for fs.idx < n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := 1
	if fs.idx < n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return sign * val
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()
	k := fs.NextInt()

	counts := make(map[int]int)
	c := 0
	for i := 0; i < n; i++ {
		x := fs.NextInt()
		if x == -1 {
			c++
		} else {
			counts[x]++
		}
	}
	K := n - c

	inv := make([]int64, n+1)
	harm := make([]int64, n+1)
	inv[1] = 1
	for i := 2; i <= n; i++ {
		inv[i] = MOD - (MOD/int64(i))*inv[int(MOD%int64(i))]%MOD
	}
	for i := 1; i <= n; i++ {
		harm[i] = harm[i-1] + inv[i]
		if harm[i] >= MOD {
			harm[i] -= MOD
		}
	}

	nmod := int64(n)
	kmod := int64(k) % MOD

	gamma := int64(0)
	pow := kmod
	for m := 2; m <= n; m++ {
		gamma += nmod * pow % MOD * inv[m] % MOD
		gamma %= MOD
		pow = pow * kmod % MOD
	}

	ans := gamma

	if K == 0 {
		sub := (nmod*harm[n]%MOD - nmod + MOD) % MOD
		ans -= sub
	} else {
		sub := nmod * ((harm[n] - harm[K] + MOD) % MOD) % MOD
		ans -= sub

		if K >= 2 {
			weight := make([]int64, K+1)
			weight[2] = nmod * kmod % MOD * inv[K] % MOD * inv[K-1] % MOD
			for t := 2; t < K; t++ {
				weight[t+1] = weight[t] * kmod % MOD * int64(t) % MOD * inv[K-t] % MOD
			}

			higher := int64(0)
			for _, s := range counts {
				comb := int64(1)
				for t := 1; t <= s; t++ {
					comb = comb * int64(s-t+1) % MOD * inv[t] % MOD
					if t >= 2 {
						higher += comb * weight[t] % MOD
						if higher >= MOD {
							higher -= MOD
						}
					}
				}
			}
			ans -= higher
		}
	}

	ans %= MOD
	if ans < 0 {
		ans += MOD
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(out, ans)
	out.Flush()
}