For problem statement at 0-999/600-699/690-699/690/problemF3.txt this is a correct solution, but verifier at 0-999/600-699/690-699/690/verifierF3.go ends with candidate runtime error on det-small-yes: runtime error: exit status 2
panic: runtime error: index out of range [0] with length 0

goroutine 1 [running]:
main.getTreeID({0x400006ee40, 0x0, 0x0}, 0xffffffffffffffff)
	/tmp/build-3899731365/solution.go:96 +0xd8
main.main()
	/tmp/build-3899731365/solution.go:156 +0x7a8

input:
1
4 2
2
1 2
2 3
1
1 2
exit status 1 can you fix the verifier? package main

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type TreeID struct {
	id1, id2 int
}

var memo = make(map[string]int)
var idCounter int

func getId(children []int) int {
	if len(children) == 0 {
		return 0
	}
	sort.Ints(children)
	var sb strings.Builder
	for _, c := range children {
		sb.WriteString(strconv.Itoa(c))
		sb.WriteByte(',')
	}
	s := sb.String()
	if id, ok := memo[s]; ok {
		return id
	}
	idCounter++
	memo[s] = idCounter
	return idCounter
}

func getCentersIgnore(adj [][]int, ignore int) []int {
	n := len(adj)
	degree := make([]int, n)
	var leaves []int
	active := 0
	for i := 0; i < n; i++ {
		if i == ignore {
			continue
		}
		active++
		d := 0
		for _, v := range adj[i] {
			if v != ignore {
				d++
			}
		}
		degree[i] = d
		if d <= 1 {
			leaves = append(leaves, i)
			degree[i] = 0
		}
	}
	count := len(leaves)
	for count < active {
		var newLeaves []int
		for _, u := range leaves {
			for _, v := range adj[u] {
				if v == ignore {
					continue
				}
				if degree[v] > 0 {
					degree[v]--
					if degree[v] == 1 {
						newLeaves = append(newLeaves, v)
					}
				}
			}
		}
		count += len(newLeaves)
		leaves = newLeaves
	}
	return leaves
}

func dfsID(adj [][]int, u, p, ignore int) int {
	var children []int
	for _, v := range adj[u] {
		if v != p && v != ignore {
			children = append(children, dfsID(adj, v, u, ignore))
		}
	}
	return getId(children)
}

func getTreeID(adj [][]int, ignore int) TreeID {
	centers := getCentersIgnore(adj, ignore)
	if len(centers) == 1 {
		id := dfsID(adj, centers[0], -1, ignore)
		return TreeID{id, id}
	} else {
		id1 := dfsID(adj, centers[0], -1, ignore)
		id2 := dfsID(adj, centers[1], -1, ignore)
		if id1 > id2 {
			id1, id2 = id2, id1
		}
		return TreeID{id1, id2}
	}
}

func main() {
	var n, k int
	if _, err := fmt.Scan(&n, &k); err != nil {
		return
	}

	if n == 2 {
		fmt.Println("1 2")
		return
	}

	adj1 := make([][]int, n-1)
	for i := 0; i < n-2; i++ {
		var u, v int
		fmt.Scan(&u, &v)
		u--
		v--
		adj1[u] = append(adj1[u], v)
		adj1[v] = append(adj1[v], u)
	}

	adj2 := make([][]int, n-1)
	for i := 0; i < n-2; i++ {
		var u, v int
		fmt.Scan(&u, &v)
		u--
		v--
		adj2[u] = append(adj2[u], v)
		adj2[v] = append(adj2[v], u)
	}

	var leaves1 []int
	for i := 0; i < n-1; i++ {
		if len(adj1[i]) == 1 {
			leaves1 = append(leaves1, i)
		}
	}

	var leaves2 []int
	for i := 0; i < n-1; i++ {
		if len(adj2[i]) == 1 {
			leaves2 = append(leaves2, i)
		}
	}

	validCores := make(map[TreeID]bool)
	for _, l2 := range leaves2 {
		id := getTreeID(adj2, l2)
		validCores[id] = true
	}

	targetID := getTreeID(adj2, -1)

	for _, l1 := range leaves1 {
		coreID := getTreeID(adj1, l1)
		if !validCores[coreID] {
			continue
		}

		for v := 0; v < n-1; v++ {
			if v == l1 {
				continue
			}

			adjCand := make([][]int, n-1)
			for i := 0; i < n-1; i++ {
				if i == l1 {
					continue
				}
				for _, neighbor := range adj1[i] {
					if neighbor != l1 {
						adjCand[i] = append(adjCand[i], neighbor)
					}
				}
			}

			adjCand[l1] = append(adjCand[l1], v)
			adjCand[v] = append(adjCand[v], l1)

			if getTreeID(adjCand, -1) == targetID {
				for i := 0; i < n-1; i++ {
					for _, neighbor := range adj1[i] {
						if i < neighbor {
							fmt.Println(i+1, neighbor+1)
						}
					}
				}
				fmt.Println(v+1, n)
				return
			}
		}
	}
}