For problem statement at 0-999/0-99/0-9/2/problemB.txt this is a correct solution, but verifier at 0-999/0-99/0-9/2/verifierB.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

func main() {
	// Use buffered I/O for speed
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	// Read matrix size n
	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	// Matrices to store the counts of factors 2 and 5 for each cell
	mat2 := make([][]int, n)
	mat5 := make([][]int, n)
	for i := 0; i < n; i++ {
		mat2[i] = make([]int, n)
		mat5[i] = make([]int, n)
	}

	zeroRow, zeroCol := -1, -1

	// Helper function to count factors of div in val
	countFactors := func(val, div int) int {
		cnt := 0
		for val > 0 && val%div == 0 {
			cnt++
			val /= div
		}
		return cnt
	}

	// Read matrix data
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			scanner.Scan()
			val, _ := strconv.Atoi(scanner.Text())

			if val == 0 {
				zeroRow, zeroCol = i, j
				// Assign cost 1 for 0 to avoid it if possible (searching for 0 cost),
				// but correct enough if answer is > 0.
				mat2[i][j] = 1
				mat5[i][j] = 1
			} else {
				mat2[i][j] = countFactors(val, 2)
				mat5[i][j] = countFactors(val, 5)
			}
		}
	}

	// DP function to find minimum path cost and the path itself
	solve := func(grid [][]int) (int, string) {
		dp := make([][]int, n)
		path := make([][]byte, n) // Stores 'D' or 'R'
		for i := 0; i < n; i++ {
			dp[i] = make([]int, n)
			path[i] = make([]byte, n)
		}

		dp[0][0] = grid[0][0]

		for i := 0; i < n; i++ {
			for j := 0; j < n; j++ {
				if i == 0 && j == 0 {
					continue
				}

				costFromTop := 1 << 30 // Infinity
				costFromLeft := 1 << 30

				if i > 0 {
					costFromTop = dp[i-1][j]
				}
				if j > 0 {
					costFromLeft = dp[i][j-1]
				}

				if costFromTop < costFromLeft {
					dp[i][j] = costFromTop + grid[i][j]
					path[i][j] = 'D'
				} else {
					dp[i][j] = costFromLeft + grid[i][j]
					path[i][j] = 'R'
				}
			}
		}

		// Reconstruct path from (n-1, n-1) to (0, 0)
		resPath := make([]byte, 0, 2*n-2)
		r, c := n-1, n-1
		for r > 0 || c > 0 {
			move := path[r][c]
			resPath = append(resPath, move)
			if move == 'D' {
				r--
			} else {
				c--
			}
		}

		// Reverse the path string
		for i, j := 0, len(resPath)-1; i < j; i, j = i+1, j-1 {
			resPath[i], resPath[j] = resPath[j], resPath[i]
		}

		return dp[n-1][n-1], string(resPath)
	}

	// Solve for factors of 2 and 5 independently
	cost2, path2 := solve(mat2)
	cost5, path5 := solve(mat5)

	bestCost := cost2
	bestPath := path2
	if cost5 < cost2 {
		bestCost = cost5
		bestPath = path5
	}

	// If there is a zero in the matrix, we can always achieve at most 1 trailing zero.
	// If our best DP solution is worse (> 1), we pick the path through the zero.
	if zeroRow != -1 && bestCost > 1 {
		fmt.Println(1)
		// Print a valid path passing through (zeroRow, zeroCol)
		// Strategy: go all the way down to zeroRow, then all the way right to zeroCol,
		// then to the end.
		for k := 0; k < zeroRow; k++ {
			fmt.Print("D")
		}
		for k := 0; k < zeroCol; k++ {
			fmt.Print("R")
		}
		for k := 0; k < n-1-zeroRow; k++ {
			fmt.Print("D")
		}
		for k := 0; k < n-1-zeroCol; k++ {
			fmt.Print("R")
		}
		fmt.Println()
	} else {
		fmt.Println(bestCost)
		fmt.Println(bestPath)
	}
}
```