For problem statement at 0-999/700-799/770-779/777/problemD.txt this is a correct solution, but verifier at 0-999/700-799/770-779/777/verifierD.go ends with case 2 failed: expected
#pz
#sidjar
got
#
#sidjar
input:
2
#pz
#sidjar
exit status 1 can you fix the verifier? ```go
package main

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

type Node struct {
	next   [26]int
	parent int
	ch     byte
	depth  int
}

func lcpDepth(nodes []Node, a, b int) int {
	da, db := nodes[a].depth, nodes[b].depth
	for da > db {
		a = nodes[a].parent
		da--
	}
	for db > da {
		b = nodes[b].parent
		db--
	}
	for a != b {
		a = nodes[a].parent
		b = nodes[b].parent
		da--
	}
	return da
}

func buildString(nodes []Node, v int) string {
	if v == 0 {
		return "#"
	}
	buf := make([]byte, nodes[v].depth+1)
	buf[0] = '#'
	i := nodes[v].depth
	for v != 0 {
		buf[i] = nodes[v].ch
		v = nodes[v].parent
		i--
	}
	return string(buf)
}

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

	var n int
	fmt.Fscan(in, &n)
	s := make([]string, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &s[i])
	}

	nodes := make([]Node, 1, 500000+5)
	for i := 0; i < 26; i++ {
		nodes[0].next[i] = -1
	}
	nodes[0].parent = -1
	nodes[0].depth = 0

	endNode := make([]int, n)

	for i := 0; i < n; i++ {
		cur := 0
		str := s[i]
		for j := 1; j < len(str); j++ {
			c := str[j] - 'a'
			nxt := nodes[cur].next[c]
			if nxt == -1 {
				nxt = len(nodes)
				var nd Node
				for k := 0; k < 26; k++ {
					nd.next[k] = -1
				}
				nd.parent = cur
				nd.ch = str[j]
				nd.depth = nodes[cur].depth + 1
				nodes = append(nodes, nd)
				nodes[cur].next[c] = nxt
			}
			cur = nxt
		}
		endNode[i] = cur
	}

	need := make([]int, n)
	need[n-1] = endNode[n-1]

	for i := n - 2; i >= 0; i-- {
		a, b := endNode[i], need[i+1]
		d := lcpDepth(nodes, a, b)
		cur := a
		for nodes[cur].depth > d {
			cur = nodes[cur].parent
		}
		need[i] = cur
	}

	for i := 0; i < n; i++ {
		fmt.Fprintln(out, buildString(nodes, need[i]))
	}
}
```