For problem statement at 0-999/400-499/400-409/403/problemE.txt this is a correct solution, but verifier at 0-999/400-499/400-409/403/verifierE.go ends with case 1 mismatch:
expected:
Blue
2
Red
2 4
Blue
2 4

got:
Blue
2
Red
2 4
Blue
4
exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"os"
	"sort"
	"strconv"
	"strings"
)

type Edge struct {
	to, id int
}

type Tree struct {
	n          int
	adj        [][]Edge
	parent     []int
	depth      []int
	heavy      []int
	head       []int
	pos        []int
	edgeNode   []int
	currentPos int
	seg        [][]int
}

func newTree(n int) *Tree {
	return &Tree{
		n:        n,
		adj:      make([][]Edge, n+1),
		parent:   make([]int, n+1),
		depth:    make([]int, n+1),
		heavy:    make([]int, n+1),
		head:     make([]int, n+1),
		pos:      make([]int, n+1),
		edgeNode: make([]int, n),
		seg:      make([][]int, 4*n+1),
	}
}

func (t *Tree) dfs1(u, p, d int) int {
	t.parent[u] = p
	t.depth[u] = d
	size := 1
	maxSub := 0
	for _, edge := range t.adj[u] {
		v := edge.to
		if v != p {
			t.edgeNode[edge.id] = v
			sub := t.dfs1(v, u, d+1)
			size += sub
			if sub > maxSub {
				maxSub = sub
				t.heavy[u] = v
			}
		}
	}
	return size
}

func (t *Tree) dfs2(u, h int) {
	t.head[u] = h
	t.currentPos++
	t.pos[u] = t.currentPos
	if t.heavy[u] != 0 {
		t.dfs2(t.heavy[u], h)
	}
	for _, edge := range t.adj[u] {
		v := edge.to
		if v != t.parent[u] && v != t.heavy[u] {
			t.dfs2(v, v)
		}
	}
}

func (t *Tree) addSeg(node, L, R, ql, qr, id int) {
	if ql <= L && R <= qr {
		t.seg[node] = append(t.seg[node], id)
		return
	}
	mid := (L + R) / 2
	if ql <= mid {
		t.addSeg(node*2, L, mid, ql, qr, id)
	}
	if qr > mid {
		t.addSeg(node*2+1, mid+1, R, ql, qr, id)
	}
}

func (t *Tree) addPath(u, v, id int) {
	for t.head[u] != t.head[v] {
		if t.depth[t.head[u]] < t.depth[t.head[v]] {
			u, v = v, u
		}
		t.addSeg(1, 1, t.n, t.pos[t.head[u]], t.pos[u], id)
		u = t.parent[t.head[u]]
	}
	if t.depth[u] > t.depth[v] {
		u, v = v, u
	}
	if t.pos[u]+1 <= t.pos[v] {
		t.addSeg(1, 1, t.n, t.pos[u]+1, t.pos[v], id)
	}
}

func (t *Tree) queryAndClear(node, L, R, p int, result *[]int, isDeleted []bool) {
	if len(t.seg[node]) > 0 {
		for _, id := range t.seg[node] {
			if !isDeleted[id] {
				isDeleted[id] = true
				*result = append(*result, id)
			}
		}
		t.seg[node] = nil
	}
	if L == R {
		return
	}
	mid := (L + R) / 2
	if p <= mid {
		t.queryAndClear(node*2, L, mid, p, result, isDeleted)
	} else {
		t.queryAndClear(node*2+1, mid+1, R, p, result, isDeleted)
	}
}

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

	readInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

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

	b := make([]int, n+1)
	for i := 1; i < n; i++ {
		b[i] = readInt()
	}

	idx := readInt()

	blueTree := newTree(n)
	for i := 1; i < n; i++ {
		u := i + 1
		v := a[i]
		blueTree.adj[u] = append(blueTree.adj[u], Edge{v, i})
		blueTree.adj[v] = append(blueTree.adj[v], Edge{u, i})
	}

	redTree := newTree(n)
	for i := 1; i < n; i++ {
		u := i + 1
		v := b[i]
		redTree.adj[u] = append(redTree.adj[u], Edge{v, i})
		redTree.adj[v] = append(redTree.adj[v], Edge{u, i})
	}

	blueTree.dfs1(1, 0, 0)
	blueTree.dfs2(1, 1)

	redTree.dfs1(1, 0, 0)
	redTree.dfs2(1, 1)

	for i := 1; i < n; i++ {
		u := i + 1
		v := b[i]
		blueTree.addPath(u, v, i)
	}

	for i := 1; i < n; i++ {
		u := i + 1
		v := a[i]
		redTree.addPath(u, v, i)
	}

	blueDeleted := make([]bool, n)
	redDeleted := make([]bool, n)

	blueStage := []int{idx}
	blueDeleted[idx] = true
	var redStage []int

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

	printSlice := func(s []int) {
		var sb strings.Builder
		for i, v := range s {
			if i > 0 {
				sb.WriteByte(' ')
			}
			sb.WriteString(strconv.Itoa(v))
		}
		sb.WriteByte('\n')
		out.WriteString(sb.String())
	}

	for len(blueStage) > 0 || len(redStage) > 0 {
		if len(blueStage) > 0 {
			out.WriteString("Blue\n")
			sort.Ints(blueStage)
			printSlice(blueStage)

			redStage = nil
			for _, id := range blueStage {
				p := blueTree.pos[blueTree.edgeNode[id]]
				blueTree.queryAndClear(1, 1, blueTree.n, p, &redStage, redDeleted)
			}
			blueStage = nil
		} else if len(redStage) > 0 {
			out.WriteString("Red\n")
			sort.Ints(redStage)
			printSlice(redStage)

			blueStage = nil
			for _, id := range redStage {
				p := redTree.pos[redTree.edgeNode[id]]
				redTree.queryAndClear(1, 1, redTree.n, p, &blueStage, blueDeleted)
			}
			redStage = nil
		}
	}
}
```