For problem statement at 0-999/100-199/100-109/109/problemE.txt this is a correct solution, but verifier at 0-999/100-199/100-109/109/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"fmt"
)

func lucky(x int64) int {
	if x == 0 {
		return 0
	}
	c := 0
	for x > 0 {
		d := x % 10
		if d == 4 || d == 7 {
			c++
		}
		x /= 10
	}
	return c
}

func lenOf(x int64) int {
	if x == 0 {
		return 1
	}
	c := 0
	for x > 0 {
		c++
		x /= 10
	}
	return c
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	var p10 [19]int64
	p10[0] = 1
	for i := 1; i <= 18; i++ {
		p10[i] = p10[i-1] * 10
	}

	var a, l int64
	if _, err := fmt.Scan(&a, &l); err != nil {
		return
	}

	var global_min_b uint64 = ^uint64(0)

	for k := 0; k <= 18; k++ {
		R := a % p10[k]
		A := a / p10[k]
		M := (R + l - 1) / p10[k]
		if M > 20 {
			continue
		}

		Tc := make([]int, M+1)
		for c := int64(0); c <= M; c++ {
			Tc[c] = lucky(A + c)
		}

		for D := 0; D <= 99; D++ {
			req0, req1 := -1, -1
			valid := true

			for c := int64(0); c <= M; c++ {
				val := int64(D) + c
				carry := int64(0)
				if val >= 100 {
					carry = 1
				}
				req := Tc[c] - lucky(val%100)
				if req < 0 {
					valid = false
					break
				}
				if carry == 0 {
					if req0 == -1 {
						req0 = req
					} else if req0 != req {
						valid = false
						break
					}
				} else {
					if req1 == -1 {
						req1 = req
					} else if req1 != req {
						valid = false
						break
					}
				}
			}

			if !valid {
				continue
			}

			req_diff := 999
			if req1 != -1 {
				req_diff = req1 - req0
				if req_diff != -1 && req_diff != 0 && req_diff != 1 {
					continue
				}
			}

			P_min := A / 100
			if P_min*100+int64(D) <= A {
				P_min++
			}

			var min_P int64 = -1
			var dfs func(int, int64, int, bool, int, int)
			dfs = func(idx int, current int64, luckyCount int, is_greater bool, last_non_nine int, L int) {
				if min_P != -1 || luckyCount > req0 || luckyCount+(L-idx) < req0 {
					return
				}
				if idx == L {
					if luckyCount == req0 {
						d := last_non_nine
						if d == -1 {
							d = 0
						}
						diff := 0
						if d == 3 || d == 6 {
							diff = 1
						} else if d == 4 || d == 7 {
							diff = -1
						}
						if req_diff == 999 || diff == req_diff {
							min_P = current
						}
					}
					return
				}
				extracted := int64(0)
				if L-1-idx < 19 && p10[L-1-idx] > 0 {
					extracted = (P_min / p10[L-1-idx]) % 10
				}
				min_d := int(extracted)
				if is_greater {
					min_d = 0
				}
				if idx == 0 && L > 1 && min_d == 0 && !is_greater {
					min_d = 1
				}
				for d := min_d; d <= 9; d++ {
					n_lucky := luckyCount
					if d == 4 || d == 7 {
						n_lucky++
					}
					n_last := last_non_nine
					if d != 9 {
						n_last = d
					}
					dfs(idx+1, current*10+int64(d), n_lucky, is_greater || (d > int(extracted)), n_last, L)
				}
			}

			P_opt := int64(-1)
			for L := max(1, lenOf(P_min)); L <= 18; L++ {
				min_P = -1
				dfs(0, 0, 0, false, -1, L)
				if min_P != -1 {
					P_opt = min_P
					break
				}
			}

			if P_opt != -1 {
				B := P_opt*100 + int64(D)
				max_B := (^uint64(0)) / uint64(p10[k])
				if uint64(B) <= max_B {
					b := uint64(B)*uint64(p10[k]) + uint64(R)
					if b < global_min_b {
						global_min_b = b
					}
				}
			}
		}
	}
	fmt.Println(global_min_b)
}
```