For problem statement at 1000-1999/1200-1299/1280-1289/1286/problemC1.txt this is a correct solution, but verifier at 1000-1999/1200-1299/1280-1289/1286/verifierC1.go ends with case 1 failed: expected tuoprevgz got ? 1 9
exit status 1 can you fix the verifier? ```go
package main

import (
	"fmt"
	"sort"
)

func sortString(s string) string {
	b := []byte(s)
	sort.Slice(b, func(i, j int) bool { return b[i] < b[j] })
	return string(b)
}

func getFreq(s string) map[byte]int {
	f := make(map[byte]int)
	for i := 0; i < len(s); i++ {
		f[s[i]]++
	}
	return f
}

func diffLetter(full, sub map[byte]int) (byte, bool) {
	var let byte
	count := 0
	for c := byte('a'); c <= byte('z'); c++ {
		f := full[c]
		s := sub[c]
		if f != s {
			if f != s+1 {
				return 0, false
			}
			count++
			let = c
		}
	}
	return let, count == 1
}

func recur(m int, norms []string) []string {
	if m == 1 {
		for _, s := range norms {
			if len(s) == 1 {
				return []string{s}
			}
		}
		return nil
	}

	var full_str string
	for _, s := range norms {
		if len(s) == m {
			full_str = s
			break
		}
	}
	full_freq := getFreq(full_str)

	var cands []string
	for _, s := range norms {
		if len(s) == m-1 {
			cands = append(cands, s)
		}
	}
	if len(cands) != 2 {
		return nil
	}

	var possibles []string
	for ch := 0; ch < 2; ch++ {
		left_norm := cands[ch]
		right_norm := cands[1-ch]
		freq_left := getFreq(left_norm)
		s_m, ok := diffLetter(full_freq, freq_left)
		if !ok {
			continue
		}
		freq_right := getFreq(right_norm)
		s_1, ok := diffLetter(full_freq, freq_right)
		if !ok {
			continue
		}

		var filtered []string
		for _, norm := range norms {
			if len(norm) > m-1 {
				continue
			}
			freq_norm := getFreq(norm)
			ok := true
			for c := byte('a'); c <= byte('z'); c++ {
				if freq_norm[c] > freq_left[c] {
					ok = false
					break
				}
			}
			if ok {
				filtered = append(filtered, norm)
			}
		}
		exp := (m - 1) * m / 2
		if len(filtered) != exp {
			continue
		}

		pref_poss := recur(m-1, filtered)
		for _, pref := range pref_poss {
			if pref[0] != s_1 {
				continue
			}
			possibles = append(possibles, pref+string(s_m))
		}
	}
	return possibles
}

func main() {
	var n int
	fmt.Scan(&n)

	fmt.Printf("? 1 %d\n", n)
	var k int
	fmt.Scan(&k)
	norms := make([]string, 0, k)
	for i := 0; i < k; i++ {
		var s string
		fmt.Scan(&s)
		norms = append(norms, sortString(s))
	}

	poss := recur(n, norms)

	if len(poss) == 0 {
		return
	}
	if len(poss) == 1 {
		fmt.Println("! " + poss[0])
		return
	}

	s1 := poss[0]
	s2 := poss[1]
	diff := -1
	for i := 0; i < n; i++ {
		if s1[i] != s2[i] {
			diff = i + 1
			break
		}
	}
	if diff == -1 {
		fmt.Println("! " + s1)
		return
	}

	fmt.Printf("? %d %d\n", diff, diff)
	var kk int
	fmt.Scan(&kk)
	var ch string
	fmt.Scan(&ch)

	if s1[diff-1] == ch[0] {
		fmt.Println("! " + s1)
	} else {
		fmt.Println("! " + s2)
	}
}
```