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

import (
	"fmt"
	"io"
	"os"
)

type Node struct {
	r, c                  int
	dir                   byte
	up, down, left, right *Node
}

func main() {
	buf, _ := io.ReadAll(os.Stdin)
	ptr := 0

	readInt := func() int {
		for ptr < len(buf) && (buf[ptr] < '0' || buf[ptr] > '9') {
			ptr++
		}
		if ptr >= len(buf) {
			return 0
		}
		res := 0
		for ptr < len(buf) && buf[ptr] >= '0' && buf[ptr] <= '9' {
			res = res*10 + int(buf[ptr]-'0')
			ptr++
		}
		return res
	}

	n := readInt()
	m := readInt()

	if n == 0 || m == 0 {
		return
	}

	var chips []*Node

	for r := 0; r < n; r++ {
		c := 0
		for ptr < len(buf) && c < m {
			ch := buf[ptr]
			ptr++
			if ch == ' ' || ch == '\n' || ch == '\r' {
				continue
			}
			if ch != '.' {
				chips = append(chips, &Node{
					r:   r,
					c:   c,
					dir: ch,
				})
			}
			c++
		}
	}

	for i := 0; i < len(chips); i++ {
		if i > 0 && chips[i].r == chips[i-1].r {
			chips[i].left = chips[i-1]
			chips[i-1].right = chips[i]
		}
	}

	lastInCol := make([]*Node, m)
	for i := 0; i < len(chips); i++ {
		c := chips[i].c
		if lastInCol[c] != nil {
			chips[i].up = lastInCol[c]
			lastInCol[c].down = chips[i]
		}
		lastInCol[c] = chips[i]
	}

	maxCount := 0
	ways := 0
	stack := make([]*Node, 0, len(chips))

	for _, startNode := range chips {
		stack = stack[:0]
		curr := startNode
		count := 0

		for curr != nil {
			var nxt *Node
			switch curr.dir {
			case 'U':
				nxt = curr.up
			case 'D':
				nxt = curr.down
			case 'L':
				nxt = curr.left
			case 'R':
				nxt = curr.right
			}

			if curr.up != nil {
				curr.up.down = curr.down
			}
			if curr.down != nil {
				curr.down.up = curr.up
			}
			if curr.left != nil {
				curr.left.right = curr.right
			}
			if curr.right != nil {
				curr.right.left = curr.left
			}

			stack = append(stack, curr)
			count++
			curr = nxt
		}

		if count > maxCount {
			maxCount = count
			ways = 1
		} else if count == maxCount {
			ways++
		}

		for i := len(stack) - 1; i >= 0; i-- {
			u := stack[i]
			if u.up != nil {
				u.up.down = u
			}
			if u.down != nil {
				u.down.up = u
			}
			if u.left != nil {
				u.left.right = u
			}
			if u.right != nil {
				u.right.left = u
			}
		}
	}

	fmt.Printf("%d %d\n", maxCount, ways)
}
```