For problem statement at 1000-1999/1800-1899/1830-1839/1833/problemE.txt this is a correct solution, but verifier at 1000-1999/1800-1899/1830-1839/1833/verifierE.go ends with case 17 failed: expected "1 2" got "2 2"
input:1
10
5 9 6 9 9 3 8 1 8 9
exit status 1 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)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	// Helper function to read the next integer
	readInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	// Read number of test cases
	// Note: We assume valid input as per problem description
	if !scanner.Scan() {
		return
	}
	t, _ := strconv.Atoi(scanner.Text())

	for i := 0; i < t; i++ {
		n := readInt()
		a := make([]int, n)
		for j := 0; j < n; j++ {
			a[j] = readInt()
		}

		// Build the undirected graph from the given neighbor preferences.
		// Since max degree is 2, using slices is efficient enough.
		// We avoid duplicate edges (e.g., if 1->2 and 2->1, it's one edge 1-2).
		adj := make([][]int, n+1)
		for j := 0; j < n; j++ {
			u := j + 1
			v := a[j]

			// Add edge u-v if not already present
			found := false
			for _, neighbor := range adj[u] {
				if neighbor == v {
					found = true
					break
				}
			}
			if !found {
				adj[u] = append(adj[u], v)
			}

			found = false
			for _, neighbor := range adj[v] {
				if neighbor == u {
					found = true
					break
				}
			}
			if !found {
				adj[v] = append(adj[v], u)
			}
		}

		vis := make([]bool, n+1)
		cycles := 0
		paths := 0

		// Analyze connected components
		for j := 1; j <= n; j++ {
			if !vis[j] {
				// BFS to find the component
				q := []int{j}
				vis[j] = true
				vCount := 0
				degSum := 0
				idx := 0
				
				for idx < len(q) {
					curr := q[idx]
					idx++
					vCount++
					degSum += len(adj[curr])
					
					for _, neighbor := range adj[curr] {
						if !vis[neighbor] {
							vis[neighbor] = true
							q = append(q, neighbor)
						}
					}
				}

				// Determine if component is a cycle or a path
				// In a component with max degree 2:
				// If sum of degrees == 2 * vertices, it's a cycle (2-regular).
				// Otherwise, it's a path.
				if degSum == 2*vCount {
					cycles++
				} else {
					paths++
				}
			}
		}

		// Calculate Min and Max round dances
		// Max: Each closed cycle counts as 1. Each path can be closed to form a cycle (counts as 1).
		// Min: Closed cycles count as 1. All paths can be linked together into a single large cycle.
		minDances := cycles
		if paths > 0 {
			minDances++
		}
		maxDances := cycles + paths

		fmt.Fprintf(writer, "%d %d\n", minDances, maxDances)
	}
}
```