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 (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	// Store grid ids to build graph
	grid := make([][]int, n)
	for i := range grid {
		grid[i] = make([]int, m)
	}

	type chip struct {
		dir int // 0:L, 1:R, 2:U, 3:D
	}
	var chips []chip

	// Read the grid
	for i := 0; i < n; i++ {
		var s string
		fmt.Fscan(in, &s)
		for j, c := range s {
			if c == '.' {
				grid[i][j] = -1
			} else {
				var d int
				switch c {
				case 'L':
					d = 0
				case 'R':
					d = 1
				case 'U':
					d = 2
				case 'D':
					d = 3
				}
				grid[i][j] = len(chips)
				chips = append(chips, chip{d})
			}
		}
	}

	numChips := len(chips)
	// Adjacency list: 4 neighbors per chip [L, R, U, D]
	// Stored as flattened array for fast copy
	initialAdj := make([]int, numChips*4)
	for i := range initialAdj {
		initialAdj[i] = -1
	}

	// Build horizontal links (L=0, R=1)
	for i := 0; i < n; i++ {
		prev := -1
		for j := 0; j < m; j++ {
			curr := grid[i][j]
			if curr != -1 {
				if prev != -1 {
					initialAdj[prev*4+1] = curr
					initialAdj[curr*4+0] = prev
				}
				prev = curr
			}
		}
	}

	// Build vertical links (U=2, D=3)
	for j := 0; j < m; j++ {
		prev := -1
		for i := 0; i < n; i++ {
			curr := grid[i][j]
			if curr != -1 {
				if prev != -1 {
					initialAdj[prev*4+3] = curr
					initialAdj[curr*4+2] = prev
				}
				prev = curr
			}
		}
	}

	maxScore := 0
	count := 0
	
	// Preallocate buffer for simulation
	adj := make([]int, numChips*4)

	for start := 0; start < numChips; start++ {
		// Restore graph state
		copy(adj, initialAdj)
		
		curr := start
		score := 0
		
		for {
			score++
			dir := chips[curr].dir
			next := adj[curr*4+dir]

			// Remove curr from doubly linked lists
			// Horizontal (indices 0 and 1)
			l := adj[curr*4+0]
			r := adj[curr*4+1]
			if l != -1 {
				adj[l*4+1] = r
			}
			if r != -1 {
				adj[r*4+0] = l
			}

			// Vertical (indices 2 and 3)
			u := adj[curr*4+2]
			d := adj[curr*4+3]
			if u != -1 {
				adj[u*4+3] = d
			}
			if d != -1 {
				adj[d*4+2] = u
			}

			if next == -1 {
				break
			}
			curr = next
		}

		if score > maxScore {
			maxScore = score
			count = 1
		} else if score == maxScore {
			count++
		}
	}

	fmt.Fprintln(out, maxScore, count)
}
```