For problem statement at 1000-1999/1800-1899/1810-1819/1810/problemG.txt this is a correct solution, but verifier at 1000-1999/1800-1899/1810-1819/1810/verifierG.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"io"
	"os"
	"strconv"
	"strings"
)

const MOD int64 = 1000000007

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int64 {
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if (c >= '0' && c <= '9') || c == '-' {
			break
		}
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var v int64
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		v = v*10 + int64(c-'0')
		fs.idx++
	}
	return v * sign
}

func powMod(a, e int64) int64 {
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func main() {
	fs := NewFastScanner()
	t := int(fs.NextInt())
	var out strings.Builder
	for ; t > 0; t-- {
		n := int(fs.NextInt())
		p := make([]int64, n+1)
		q := make([]int64, n+1)
		for i := 1; i <= n; i++ {
			x := fs.NextInt()
			y := fs.NextInt()
			p[i] = x * powMod(y, MOD-2) % MOD
			q[i] = (1 - p[i] + MOD) % MOD
		}
		h := make([]int64, n+1)
		for i := 0; i <= n; i++ {
			h[i] = fs.NextInt() % MOD
		}
		delta := make([]int64, n)
		for i := 0; i < n; i++ {
			delta[i] = h[i+1] - h[i]
			if delta[i] < 0 {
				delta[i] += MOD
			}
		}

		size := 2*n + 5
		dist := make([]int64, size)
		next := make([]int64, size)
		for i := 0; i < n; i++ {
			dist[i] = delta[i]
		}

		ans := h[0]
		maxH := n - 1
		for i := 1; i <= n; i++ {
			ans += p[i] * dist[0] % MOD
			if ans >= MOD {
				ans -= MOD
			}
			if i > 1 {
				out.WriteByte(' ')
			}
			out.WriteString(strconv.FormatInt(ans, 10))
			if i == n {
				break
			}

			dist[maxH+1] = 0
			dist[maxH+2] = 0
			newMax := maxH + 1

			next[0] = p[i] * dist[1] % MOD
			for hgt := 1; hgt <= newMax; hgt++ {
				next[hgt] = (q[i]*dist[hgt-1] + p[i]*dist[hgt+1]) % MOD
			}

			dist, next = next, dist
			maxH = newMax
		}
		out.WriteByte('\n')
	}
	os.Stdout.WriteString(out.String())
}
```