For problem statement at 0-999/700-799/750-759/753/problemC.txt this is a correct solution, but verifier at 0-999/700-799/750-759/753/verifierC.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

func main() {
	all := make([]string, 0, 5040)
	masks := make([]uint16, 0, 5040)

	for d0 := 0; d0 <= 9; d0++ {
		for d1 := 0; d1 <= 9; d1++ {
			if d1 == d0 {
				continue
			}
			for d2 := 0; d2 <= 9; d2++ {
				if d2 == d0 || d2 == d1 {
					continue
				}
				for d3 := 0; d3 <= 9; d3++ {
					if d3 == d0 || d3 == d1 || d3 == d2 {
						continue
					}
					s := []byte{byte('0' + d0), byte('0' + d1), byte('0' + d2), byte('0' + d3)}
					all = append(all, string(s))
					var m uint16
					m |= (uint16(1) << uint(d0))
					m |= (uint16(1) << uint(d1))
					m |= (uint16(1) << uint(d2))
					m |= (uint16(1) << uint(d3))
					masks = append(masks, m)
				}
			}
		}
	}

	N := len(all)
	codes := make([]byte, N*N)
	for i := 0; i < N; i++ {
		si := all[i]
		mi := masks[i]
		base := i * N
		for j := 0; j < N; j++ {
			sj := all[j]
			b := 0
			if si[0] == sj[0] {
				b++
			}
			if si[1] == sj[1] {
				b++
			}
			if si[2] == sj[2] {
				b++
			}
			if si[3] == sj[3] {
				b++
			}
			m := bits.OnesCount16(mi & masks[j])
			c := m - b
			codes[base+j] = byte(b*5 + c)
		}
	}

	cands := make([]int, N)
	for i := 0; i < N; i++ {
		cands[i] = i
	}

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

	counts := make([]int, 25)

	for attempt := 0; attempt < 7; attempt++ {
		var guessIdx int
		if len(cands) == 1 {
			guessIdx = cands[0]
		} else {
			bestScore := int(1 << 30)
			bestIdx := cands[0]
			for _, g := range cands {
				for k := 0; k < 25; k++ {
					counts[k] = 0
				}
				gb := g * N
				for _, s := range cands {
					counts[codes[gb+s]]++
				}
				maxv := 0
				for k := 0; k < 25; k++ {
					if counts[k] > maxv {
						maxv = counts[k]
					}
				}
				if maxv < bestScore {
					bestScore = maxv
					bestIdx = g
				}
			}
			guessIdx = bestIdx
		}

		fmt.Fprintln(writer, all[guessIdx])
		writer.Flush()

		var bulls, cows int
		_, err := fmt.Fscan(reader, &bulls, &cows)
		if err != nil {
			return
		}
		if bulls == 4 {
			return
		}

		want := byte(bulls*5 + cows)
		gb := guessIdx * N
		newCands := newSlice(len(cands))
		for _, s := range cands {
			if codes[gb+s] == want {
				newCands = append(newCands, s)
			}
		}
		cands = newCands
		if len(cands) == 0 {
			return
		}
	}
}

func newSlice(n int) []int {
	if n < 0 {
		n = 0
	}
	return make([]int, 0, n)
}
```