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

import (
	"fmt"
	"math"
	"strconv"
)

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
	}

	const MAXV = 10000
	isLucky := make([]bool, MAXV+1)
	var lucky []int
	for i := 1; i <= MAXV; i++ {
		s := strconv.Itoa(i)
		ok := true
		for _, c := range s {
			if c != '4' && c != '7' {
				ok = false
				break
			}
		}
		if ok {
			isLucky[i] = true
			lucky = append(lucky, i)
		}
	}

	B := int(math.Sqrt(float64(n))) + 1
	if B < 320 {
		B = 320
	}
	numBlocks := (n + B - 1) / B
	base := make([][]int, numBlocks)
	lazy := make([]int, numBlocks)
	freq := make([][]int, numBlocks)
	for b := 0; b < numBlocks; b++ {
		st := b * B
		en := st + B
		if en > n {
			en = n
		}
		sz := en - st
		base[b] = make([]int, sz)
		freq[b] = make([]int, MAXV*2+1)
		for j := 0; j < sz; j++ {
			v := a[st+j]
			base[b][j] = v
			freq[b][v]++
		}
	}

	propagate := func(b int) {
		if lazy[b] == 0 {
			return
		}
		sz := len(base[b])
		for j := 0; j < sz; j++ {
			oldv := base[b][j]
			base[b][j] += lazy[b]
			newv := base[b][j]
			freq[b][oldv]--
			freq[b][newv]++
		}
		lazy[b] = 0
	}

	update := func(left, right, d int) {
		bl := left / B
		br := right / B
		if bl == br {
			propagate(bl)
			st := bl * B
			for pos := left; pos <= right; pos++ {
				j := pos - st
				oldv := base[bl][j]
				base[bl][j] += d
				newv := base[bl][j]
				freq[bl][oldv]--
				freq[bl][newv]++
			}
		} else {
			// partial start
			propagate(bl)
			st := bl * B
			en := st + len(base[bl]) - 1
			for pos := left; pos <= en; pos++ {
				j := pos - st
				oldv := base[bl][j]
				base[bl][j] += d
				newv := base[bl][j]
				freq[bl][oldv]--
				freq[bl][newv]++
			}
			// full
			for bb := bl + 1; bb < br; bb++ {
				lazy[bb] += d
			}
			// partial end
			propagate(br)
			st = br * B
			for pos := st; pos <= right; pos++ {
				j := pos - st
				oldv := base[br][j]
				base[br][j] += d
				newv := base[br][j]
				freq[br][oldv]--
				freq[br][newv]++
			}
		}
	}

	query := func(left, right int) int {
		bl := left / B
		br := right / B
		cnt := 0
		if bl == br {
			propagate(bl)
			st := bl * B
			for pos := left; pos <= right; pos++ {
				j := pos - st
				v := base[bl][j]
				if v <= MAXV && isLucky[v] {
					cnt++
				}
			}
		} else {
			// partial start
			propagate(bl)
			st := bl * B
			en := st + len(base[bl]) - 1
			for pos := left; pos <= en; pos++ {
				j := pos - st
				v := base[bl][j]
				if v <= MAXV && isLucky[v] {
					cnt++
				}
			}
			// full
			for bb := bl + 1; bb < br; bb++ {
				for _, L := range lucky {
					req := L - lazy[bb]
					if req >= 0 && req <= MAXV*2 {
						cnt += freq[bb][req]
					}
				}
			}
			// partial end
			propagate(br)
			st = br * B
			for pos := st; pos <= right; pos++ {
				j := pos - st
				v := base[br][j]
				if v <= MAXV && isLucky[v] {
					cnt++
				}
			}
		}
		return cnt
	}

	for qi := 0; qi < m; qi++ {
		var op string
		fmt.Scan(&op)
		if op == "add" {
			var l, r, d int
			fmt.Scan(&l, &r, &d)
			update(l-1, r-1, d)
		} else {
			var l, r int
			fmt.Scan(&l, &r)
			res := query(l-1, r-1)
			fmt.Println(res)
		}
	}
}
```