For problem statement at 0-999/300-399/380-389/386/problemD.txt this is a correct solution, but verifier at 0-999/300-399/380-389/386/verifierD.go ends with All tests passed can you fix the verifier? ```go
package main

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

const B = 71

func sort3(a, b, c int) (int, int, int) {
	if a > b {
		a, b = b, a
	}
	if b > c {
		b, c = c, b
	}
	if a > b {
		a, b = b, a
	}
	return a, b, c
}

func encode(a, b, c int) int {
	return (a*B + b)*B + c
}

func decode(x int) (int, int, int) {
	c := x % B
	x /= B
	b := x % B
	a := x / B
	return a, b, c
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

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

	var a, b, c int
	fmt.Fscan(in, &a, &b, &c)
	a, b, c = sort3(a, b, c)

	mat := make([][]byte, n+1)
	for i := 1; i <= n; i++ {
		var s string
		fmt.Fscan(in, &s)
		row := make([]byte, n+1)
		for j := 1; j <= n; j++ {
			row[j] = s[j-1]
		}
		mat[i] = row
	}

	start := encode(a, b, c)
	goal := encode(1, 2, 3)

	size := B * B * B
	dist := make([]int, size)
	prev := make([]int, size)
	moveFrom := make([]int, size)
	moveTo := make([]int, size)

	for i := 0; i < size; i++ {
		dist[i] = -1
		prev[i] = -1
	}

	queue := make([]int, 0, 60000)
	queue = append(queue, start)
	dist[start] = 0

	for head := 0; head < len(queue) && dist[goal] == -1; head++ {
		cur := queue[head]
		x, y, z := decode(cur)

		color := mat[y][z]
		for v := 1; v <= n; v++ {
			if v == x || v == y || v == z {
				continue
			}
			if mat[x][v] == color {
				p, q, r := sort3(v, y, z)
				next := encode(p, q, r)
				if dist[next] == -1 {
					dist[next] = dist[cur] + 1
					prev[next] = cur
					moveFrom[next] = x
					moveTo[next] = v
					queue = append(queue, next)
				}
			}
		}

		color = mat[x][z]
		for v := 1; v <= n; v++ {
			if v == x || v == y || v == z {
				continue
			}
			if mat[y][v] == color {
				p, q, r := sort3(x, v, z)
				next := encode(p, q, r)
				if dist[next] == -1 {
					dist[next] = dist[cur] + 1
					prev[next] = cur
					moveFrom[next] = y
					moveTo[next] = v
					queue = append(queue, next)
				}
			}
		}

		color = mat[x][y]
		for v := 1; v <= n; v++ {
			if v == x || v == y || v == z {
				continue
			}
			if mat[z][v] == color {
				p, q, r := sort3(x, y, v)
				next := encode(p, q, r)
				if dist[next] == -1 {
					dist[next] = dist[cur] + 1
					prev[next] = cur
					moveFrom[next] = z
					moveTo[next] = v
					queue = append(queue, next)
				}
			}
		}
	}

	if dist[goal] == -1 {
		fmt.Fprintln(out, -1)
		return
	}

	pathFrom := make([]int, 0, dist[goal])
	pathTo := make([]int, 0, dist[goal])

	for cur := goal; cur != start; cur = prev[cur] {
		pathFrom = append(pathFrom, moveFrom[cur])
		pathTo = append(pathTo, moveTo[cur])
	}

	fmt.Fprintln(out, dist[goal])
	for i := len(pathFrom) - 1; i >= 0; i-- {
		fmt.Fprintln(out, pathFrom[i], pathTo[i])
	}
}
```