For problem statement at 1000-1999/1700-1799/1710-1719/1718/problemB.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1710-1719/1718/verifierB.go ends with All 100 tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"io"
	"os"
)

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int64 {
		for p < len(data) && (data[p] < '0' || data[p] > '9') {
			p++
		}
		var v int64
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			v = v*10 + int64(data[p]-'0')
			p++
		}
		return v
	}

	const maxTotal int64 = 100000000000

	fib := []int64{1, 1}
	pref := []int64{1, 2}
	for pref[len(pref)-1] < maxTotal {
		nxt := fib[len(fib)-1] + fib[len(fib)-2]
		fib = append(fib, nxt)
		pref = append(pref, pref[len(pref)-1]+nxt)
	}

	maxInd := make([]int64, len(fib))
	for i := 0; i < len(fib); i++ {
		if i <= 1 {
			maxInd[i] = 1
		} else {
			a := maxInd[i-1]
			b := fib[i] + maxInd[i-2]
			if a > b {
				maxInd[i] = a
			} else {
				maxInd[i] = b
			}
		}
	}

	pos := make(map[int64]int, len(pref))
	for i, v := range pref {
		pos[v] = i
	}

	t := int(nextInt())
	out := make([]byte, 0, t*4)

	for ; t > 0; t-- {
		k := int(nextInt())
		rem := make([]int64, k)
		var sum int64
		for i := 0; i < k; i++ {
			rem[i] = nextInt()
			sum += rem[i]
		}

		m, ok := pos[sum]
		possible := ok

		if possible {
			prev := -1
			for n := m; n >= 0 && possible; n-- {
				limCur := maxInd[n]
				var limPrev int64
				if n > 0 {
					limPrev = maxInd[n-1]
				}

				if prev != -1 && rem[prev] > limPrev {
					possible = false
					break
				}

				forced := -1
				exact := -1

				for i := 0; i < k; i++ {
					if rem[i] > limCur {
						possible = false
						break
					}
					if i == prev {
						continue
					}
					if rem[i] > limPrev {
						if forced != -1 {
							possible = false
							break
						}
						forced = i
					} else if rem[i] == fib[n] {
						exact = i
					}
				}

				if !possible {
					break
				}

				chosen := -1
				if forced != -1 {
					chosen = forced
				} else if exact != -1 {
					chosen = exact
				} else {
					possible = false
					break
				}

				rem[chosen] -= fib[n]
				prev = chosen
			}

			if possible {
				for i := 0; i < k; i++ {
					if rem[i] != 0 {
						possible = false
						break
					}
				}
			}
		}

		if possible {
			out = append(out, 'Y', 'E', 'S', '\n')
		} else {
			out = append(out, 'N', 'O', '\n')
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out)
	w.Flush()
}
```