For problem statement at 0-999/0-99/90-99/95/problemD.txt this is a correct solution, but verifier at 0-999/0-99/90-99/95/verifierD.go ends with All tests passed can you fix the verifier? ```go
package main

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

const MOD = 1000000007

var dp [1005][1005][2]int
var K int

func initDP(maxLen int) {
	for d := 1; d <= K+1; d++ {
		dp[0][d][0] = 1
		dp[0][d][1] = 1
	}

	for rem := 1; rem <= maxLen; rem++ {
		for dist := 1; dist <= K+1; dist++ {
			for started := 0; started < 2; started++ {
				sum := 0
				isStarted := started == 1

				for digit := 0; digit <= 9; digit++ {
					var nDist int
					var nStarted bool
					valid := true

					isLucky := (digit == 4 || digit == 7)

					if !isStarted {
						if digit == 0 {
							nStarted = false
							nDist = K + 1
						} else {
							nStarted = true
							if isLucky {
								nDist = 1
							} else {
								nDist = K + 1
							}
						}
					} else {
						nStarted = true
						if isLucky {
							if dist <= K {
								valid = false
							}
							nDist = 1
						} else {
							nDist = dist + 1
							if nDist > K+1 {
								nDist = K + 1
							}
						}
					}

					if valid {
						stIdx := 0
						if nStarted {
							stIdx = 1
						}
						sum = (sum + dp[rem-1][nDist][stIdx]) % MOD
					}
				}
				dp[rem][dist][started] = sum
			}
		}
	}
}

func countBad(s string) int {
	n := len(s)
	dist := K + 1
	started := false
	ans := 0

	for i := 0; i < n; i++ {
		limit := int(s[i] - '0')
		rem := n - 1 - i

		for digit := 0; digit < limit; digit++ {
			var nDist int
			var nStarted bool
			valid := true
			isLucky := (digit == 4 || digit == 7)

			if !started {
				if digit == 0 {
					nStarted = false
					nDist = K + 1
				} else {
					nStarted = true
					if isLucky {
						nDist = 1
					} else {
						nDist = K + 1
					}
				}
			} else {
				nStarted = true
				if isLucky {
					if dist <= K {
						valid = false
					}
					nDist = 1
				} else {
					nDist = dist + 1
					if nDist > K+1 {
						nDist = K + 1
					}
				}
			}

			if valid {
				stIdx := 0
				if nStarted {
					stIdx = 1
				}
				ans = (ans + dp[rem][nDist][stIdx]) % MOD
			}
		}

		isLucky := (limit == 4 || limit == 7)
		if !started {
			if limit == 0 {
				started = false
				dist = K + 1
			} else {
				started = true
				if isLucky {
					dist = 1
				} else {
					dist = K + 1
				}
			}
		} else {
			if isLucky {
				if dist <= K {
					return ans
				}
				dist = 1
			} else {
				dist++
				if dist > K+1 {
					dist = K + 1
				}
			}
		}
	}
	ans = (ans + 1) % MOD
	return ans
}

func solveString(s string) int {
	val := 0
	for i := 0; i < len(s); i++ {
		val = (val*10 + int(s[i]-'0')) % MOD
	}

	bad := countBad(s)
	badInRange := (bad - 1 + MOD) % MOD

	res := (val - badInRange + MOD) % MOD
	return res
}

func decString(s string) string {
	b := []byte(s)
	n := len(b)
	for i := n - 1; i >= 0; i-- {
		if b[i] > '0' {
			b[i]--
			if b[0] == '0' && n > 1 {
				return string(b[1:])
			}
			return string(b)
		}
		b[i] = '9'
	}
	return "0"
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t, &K)

	initDP(1002)

	for i := 0; i < t; i++ {
		var l, r string
		fmt.Fscan(reader, &l, &r)

		ansR := solveString(r)

		lMinus1 := decString(l)
		ansL := solveString(lMinus1)

		ans := (ansR - ansL + MOD) % MOD
		fmt.Fprintln(writer, ans)
	}
}
```