For problem statement at 0-999/500-599/580-589/587/problemB.txt this is a correct solution, but verifier at 0-999/500-599/580-589/587/verifierB.go ends with case 33 failed: expected 72972974 got 89867919
input:
19 235 10
69 268 189 664 198 24 469 305 781 951 651 948 318 309 69 432 452 382 357
exit status 1 can you fix the verifier? package main

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

type Scanner struct {
	buf []byte
	pos int
}

func NewScanner() *Scanner {
	b, _ := io.ReadAll(os.Stdin)
	return &Scanner{buf: b, pos: 0}
}

func (s *Scanner) nextInt() int {
	for s.pos < len(s.buf) && s.buf[s.pos] <= ' ' {
		s.pos++
	}
	if s.pos >= len(s.buf) {
		return 0
	}
	res := 0
	for s.pos < len(s.buf) && s.buf[s.pos] > ' ' {
		res = res*10 + int(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

func (s *Scanner) nextInt64() int64 {
	for s.pos < len(s.buf) && s.buf[s.pos] <= ' ' {
		s.pos++
	}
	if s.pos >= len(s.buf) {
		return 0
	}
	res := int64(0)
	for s.pos < len(s.buf) && s.buf[s.pos] > ' ' {
		res = res*10 + int64(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

type Element struct {
	val int
	id  int
}

func main() {
	scanner := NewScanner()
	if scanner.pos >= len(scanner.buf) {
		return
	}
	n := scanner.nextInt()
	if n == 0 {
		return
	}
	l := scanner.nextInt64()
	k := scanner.nextInt()

	a := make([]int, n)
	elements := make([]Element, n)
	for i := 0; i < n; i++ {
		a[i] = scanner.nextInt()
		elements[i] = Element{val: a[i], id: i}
	}

	sort.Slice(elements, func(i, j int) bool {
		return elements[i].val < elements[j].val
	})

	rank := 0
	a[elements[0].id] = 0
	for i := 1; i < n; i++ {
		if elements[i].val > elements[i-1].val {
			rank++
		}
		a[elements[i].id] = rank
	}
	M := rank + 1

	ans := int64(0)
	MOD := int64(1000000007)
	f := make([]int64, n)
	for i := 0; i < n; i++ {
		f[i] = 1
	}

	L := l / int64(n)
	rem := int(l % int64(n))

	S := make([]int64, M)
	next_f := make([]int64, n)

	for j := 1; j <= k; j++ {
		blocksFull := L - int64(j) + 1
		if blocksFull < 0 {
			break
		}

		sumFull := int64(0)
		for i := 0; i < n; i++ {
			sumFull += f[i]
			if sumFull >= MOD {
				sumFull -= MOD
			}
		}

		sumPartial := int64(0)
		for i := 0; i < rem; i++ {
			sumPartial += f[i]
			if sumPartial >= MOD {
				sumPartial -= MOD
			}
		}

		if blocksFull > 0 {
			ans = (ans + (blocksFull%MOD)*sumFull) % MOD
		}
		if blocksFull >= 0 {
			ans = (ans + sumPartial) % MOD
		}

		if j == k {
			break
		}

		for i := 0; i < M; i++ {
			S[i] = 0
		}
		for i := 0; i < n; i++ {
			S[a[i]] += f[i]
			if S[a[i]] >= MOD {
				S[a[i]] -= MOD
			}
		}
		for i := 1; i < M; i++ {
			S[i] += S[i-1]
			if S[i] >= MOD {
				S[i] -= MOD
			}
		}
		for i := 0; i < n; i++ {
			next_f[i] = S[a[i]]
		}

		f, next_f = next_f, f
	}

	fmt.Println(ans)
}