For problem statement at 0-999/500-599/560-569/566/problemA.txt this is a correct solution, but verifier at 0-999/500-599/560-569/566/verifierA.go ends with invalid output on test 1: NO
exit status 1 can you fix the verifier? package main

import (
	"fmt"
	"io"
	"os"
	"strconv"
	"strings"
	"unicode/utf8"
)

func parseIntLine(s string) (int, bool) {
	f := strings.Fields(strings.TrimSpace(s))
	if len(f) != 1 {
		return 0, false
	}
	v, err := strconv.Atoi(f[0])
	if err != nil || v < 0 {
		return 0, false
	}
	return v, true
}

func parseTwoIntLine(s string) (int, int, bool) {
	f := strings.Fields(strings.TrimSpace(s))
	if len(f) != 2 {
		return 0, 0, false
	}
	a, err1 := strconv.Atoi(f[0])
	b, err2 := strconv.Atoi(f[1])
	if err1 != nil || err2 != nil || a < 0 || b < 0 {
		return 0, 0, false
	}
	return a, b, true
}

func splitPairLine(s string) (string, string, bool) {
	for _, d := range []string{"|", ";", "\t", ","} {
		if idx := strings.Index(s, d); idx >= 0 {
			a := strings.TrimSpace(s[:idx])
			b := strings.TrimSpace(s[idx+len(d):])
			if a != "" && b != "" {
				return a, b, true
			}
		}
	}
	return "", "", false
}

func normalizeToken(s string) string {
	s = strings.TrimSpace(s)
	s = strings.Trim(s, ".,;:")
	s = strings.ReplaceAll(s, ".", "")
	s = strings.ToLower(s)
	return s
}

func parseName(s string) []string {
	fields := strings.Fields(strings.TrimSpace(s))
	res := make([]string, 0, len(fields))
	for _, f := range fields {
		t := normalizeToken(f)
		if t != "" {
			res = append(res, t)
		}
	}
	return res
}

func firstRune(s string) rune {
	r, _ := utf8.DecodeRuneInString(s)
	return r
}

func partMatch(a, b string) bool {
	if a == "" || b == "" {
		return false
	}
	if a == b {
		return true
	}
	ra := firstRune(a)
	rb := firstRune(b)
	if ra != rb {
		return false
	}
	if utf8.RuneCountInString(a) == 1 || utf8.RuneCountInString(b) == 1 {
		return true
	}
	return false
}

func nameMatch(a, b []string) bool {
	if len(a) < 2 || len(b) < 2 {
		return false
	}
	if a[len(a)-1] != b[len(b)-1] {
		return false
	}
	if !partMatch(a[0], b[0]) {
		return false
	}
	am := a[1 : len(a)-1]
	bm := b[1 : len(b)-1]
	if len(am) == 0 || len(bm) == 0 {
		return true
	}
	if len(am) != len(bm) {
		return false
	}
	for i := range am {
		if !partMatch(am[i], bm[i]) {
			return false
		}
	}
	return true
}

func solvePairLines(lines []string) string {
	var sb strings.Builder
	for i := 0; i+1 < len(lines); i += 2 {
		if i > 0 {
			sb.WriteByte('\n')
		}
		if nameMatch(parseName(lines[i]), parseName(lines[i+1])) {
			sb.WriteString("YES")
		} else {
			sb.WriteString("NO")
		}
	}
	return sb.String()
}

func canSplitAll(lines []string) bool {
	for _, line := range lines {
		if _, _, ok := splitPairLine(line); !ok {
			return false
		}
	}
	return true
}

func solveDelimited(lines []string) string {
	var sb strings.Builder
	for i, line := range lines {
		if i > 0 {
			sb.WriteByte('\n')
		}
		a, b, _ := splitPairLine(line)
		if nameMatch(parseName(a), parseName(b)) {
			sb.WriteString("YES")
		} else {
			sb.WriteString("NO")
		}
	}
	return sb.String()
}

func solveIntersection(a, b []string) string {
	cnt := map[string]int{}
	for _, s := range a {
		k := strings.ToLower(strings.TrimSpace(s))
		cnt[k]++
	}
	ans := 0
	for _, s := range b {
		k := strings.ToLower(strings.TrimSpace(s))
		if cnt[k] > 0 {
			cnt[k]--
			ans++
		}
	}
	return strconv.Itoa(ans)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	text := strings.ReplaceAll(string(data), "\r\n", "\n")
	text = strings.ReplaceAll(text, "\r", "\n")
	raw := strings.Split(text, "\n")
	lines := make([]string, 0, len(raw))
	for _, line := range raw {
		line = strings.TrimSpace(line)
		if line != "" {
			lines = append(lines, line)
		}
	}
	if len(lines) == 0 {
		return
	}

	if n, m, ok := parseTwoIntLine(lines[0]); ok && len(lines) == 1+n+m {
		fmt.Print(solveIntersection(lines[1:1+n], lines[1+n:]))
		return
	}

	if t, ok := parseIntLine(lines[0]); ok {
		rem := lines[1:]
		if len(rem) == 2*t {
			fmt.Print(solvePairLines(rem))
			return
		}
		if len(rem) == t && canSplitAll(rem) {
			fmt.Print(solveDelimited(rem))
			return
		}
		if len(lines) == t+2 {
			if m, ok2 := parseIntLine(lines[t+1]); ok2 && len(lines) == t+m+2 {
				fmt.Print(solveIntersection(lines[1:1+t], lines[t+2:]))
				return
			}
		}
		if len(lines) >= t+2 {
			if m, ok2 := parseIntLine(lines[t+1]); ok2 && len(lines) == t+m+2 {
				fmt.Print(solveIntersection(lines[1:1+t], lines[t+2:]))
				return
			}
		}
	}

	if len(lines) == 1 {
		if canSplitAll(lines) {
			fmt.Print(solveDelimited(lines))
		}
		return
	}

	if len(lines) == 2 {
		fmt.Print(solvePairLines(lines))
		return
	}

	if len(lines)%2 == 0 {
		fmt.Print(solvePairLines(lines))
		return
	}

	if canSplitAll(lines) {
		fmt.Print(solveDelimited(lines))
	}
}