For problem statement at 1000-1999/1500-1599/1540-1549/1545/problemC.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1540-1549/1545/verifierC.go ends with test 1 failed
input:
1
8
1 2 3 4 5 6 7 8
2 3 4 5 6 7 8 1
3 4 5 6 7 8 1 2
4 5 6 7 8 1 2 3
5 6 7 8 1 2 3 4
6 7 8 1 2 3 4 5
7 8 1 2 3 4 5 6
8 1 2 3 4 5 6 7
2 1 3 4 5 6 7 8
2 3 4 5 6 8 7 1
3 4 5 6 7 8 2 1
4 1 6 7 8 5 2 3
5 6 7 3 1 2 8 4
6 7 8 2 1 3 4 5
5 8 1 2 3 4 7 6
8 1 6 3 4 5 2 7
expected:1
1 2 3 5 6 7 4 8
actual:1
1 7 4 8 6 5 2 3

exit status 1 can you fix the verifier? package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	if !scanner.Scan() {
		return
	}
	t, _ = strconv.Atoi(scanner.Text())

	for tc := 0; tc < t; tc++ {
		scanner.Scan()
		n, _ := strconv.Atoi(scanner.Text())

		A := make([][]int, 2*n+1)
		for i := 1; i <= 2*n; i++ {
			A[i] = make([]int, n+1)
			for j := 1; j <= n; j++ {
				scanner.Scan()
				A[i][j], _ = strconv.Atoi(scanner.Text())
			}
		}

		available := make([]bool, 2*n+1)
		for i := 1; i <= 2*n; i++ {
			available[i] = true
		}

		covered := make([][]bool, n+1)
		deg := make([][]int, n+1)
		arrays_with := make([][][]int, n+1)
		for i := 1; i <= n; i++ {
			covered[i] = make([]bool, n+1)
			deg[i] = make([]int, n+1)
			arrays_with[i] = make([][]int, n+1)
		}

		for i := 1; i <= 2*n; i++ {
			for c := 1; c <= n; c++ {
				v := A[i][c]
				deg[c][v]++
				arrays_with[c][v] = append(arrays_with[c][v], i)
			}
		}

		q := make([][2]int, 0)
		for c := 1; c <= n; c++ {
			for v := 1; v <= n; v++ {
				if deg[c][v] == 1 {
					q = append(q, [2]int{c, v})
				}
			}
		}

		chosen := make([]int, 0, n)

		for len(q) > 0 {
			item := q[0]
			q = q[1:]
			c, v := item[0], item[1]
			if covered[c][v] {
				continue
			}

			var chosen_arr int = -1
			for _, arr := range arrays_with[c][v] {
				if available[arr] {
					chosen_arr = arr
					break
				}
			}
			if chosen_arr == -1 {
				continue
			}

			chosen = append(chosen, chosen_arr)
			available[chosen_arr] = false

			for c1 := 1; c1 <= n; c1++ {
				v1 := A[chosen_arr][c1]
				if covered[c1][v1] {
					continue
				}
				covered[c1][v1] = true

				for _, B := range arrays_with[c1][v1] {
					if available[B] {
						available[B] = false
						for c2 := 1; c2 <= n; c2++ {
							v2 := A[B][c2]
							if !covered[c2][v2] {
								deg[c2][v2]--
								if deg[c2][v2] == 1 {
									q = append(q, [2]int{c2, v2})
								}
							}
						}
					}
				}
			}
		}

		ans := 1
		MOD := 998244353

		color := make([]int, 2*n+1)
		for j := 1; j <= 2*n; j++ {
			color[j] = -1
		}

		for i := 1; i <= 2*n; i++ {
			if available[i] && color[i] == -1 {
				ans = (ans * 2) % MOD
				q_arr := []int{i}
				color[i] = 0

				for len(q_arr) > 0 {
					curr := q_arr[0]
					q_arr = q_arr[1:]

					if color[curr] == 0 {
						chosen = append(chosen, curr)
					}

					for c := 1; c <= n; c++ {
						v := A[curr][c]
						if !covered[c][v] {
							for _, neighbor := range arrays_with[c][v] {
								if available[neighbor] && color[neighbor] == -1 {
									color[neighbor] = 1 - color[curr]
									q_arr = append(q_arr, neighbor)
								}
							}
						}
					}
				}
			}
		}

		fmt.Fprintln(out, ans)
		for i, idx := range chosen {
			if i > 0 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, idx)
		}
		fmt.Fprintln(out)
	}
}