For problem statement at 1000-1999/1000-1099/1080-1089/1081/problemF.txt this is a correct solution, but verifier at 1000-1999/1000-1099/1080-1089/1081/verifierF.go ends with Problem F is interactive and cannot be automatically verified. can you fix the verifier? package main

import (
	"fmt"
	"math/rand"
	"time"
)

func modInverse(a, m int) int {
	return power(a, m-2, m)
}

func power(base, exp, mod int) int {
	res := 1
	base %= mod
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % mod
		}
		base = (base * base) % mod
		exp /= 2
	}
	return res
}

func main() {
	rand.Seed(time.Now().UnixNano())

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

	P := 1000000007
	basis := make([][]int, n+1)
	rank := 0

	insert := func(row []int) bool {
		for i := 1; i <= n; i++ {
			if row[i] == 0 {
				continue
			}
			if basis[i] == nil {
				inv := modInverse(row[i], P)
				for j := i; j <= n+1; j++ {
					row[j] = (row[j] * inv) % P
				}
				basis[i] = append([]int(nil), row...)
				rank++
				return true
			} else {
				coef := row[i]
				for j := i; j <= n+1; j++ {
					row[j] = (row[j] - coef*basis[i][j]) % P
					if row[j] < 0 {
						row[j] += P
					}
				}
			}
		}
		return false
	}

	initRow := make([]int, n+2)
	for i := 1; i <= n; i++ {
		initRow[i] = 1
	}
	initRow[n+1] = t % P
	insert(initRow)

	f := make([]int, n+1)
	c := t

	queries := 0
	for rank < n && queries < 10000 {
		var l, r int
		for {
			l = rand.Intn(n) + 1
			r = l + rand.Intn(n-l+1)
			if (l+r)%2 == n%2 {
				break
			}
		}

		fmt.Printf("? %d %d\n", l, r)
		queries++

		var c_prime int
		fmt.Scan(&c_prime)
		if c_prime == -1 {
			return
		}

		diff_parity := ((c_prime - c) % 2 + 2) % 2
		L1 := r
		L2 := n - l + 1

		var L int
		var S []int
		if L1%2 == diff_parity {
			L = L1
			for j := 1; j <= r; j++ {
				S = append(S, j)
			}
		} else {
			L = L2
			for j := l; j <= n; j++ {
				S = append(S, j)
			}
		}

		k := (c + L - c_prime) / 2

		sum_f := 0
		for _, j := range S {
			sum_f += f[j]
		}

		row := make([]int, n+2)
		for _, j := range S {
			aj := (1 - 2*f[j]) % P
			if aj < 0 {
				aj += P
			}
			row[j] = aj
		}
		b := (k - sum_f) % P
		if b < 0 {
			b += P
		}
		row[n+1] = b

		insert(row)

		for _, j := range S {
			f[j] = 1 - f[j]
		}
		c = c_prime
	}

	ans := make([]int, n+1)
	for i := n; i >= 1; i-- {
		if basis[i] == nil {
			continue
		}
		ans[i] = basis[i][n+1]
		for j := i + 1; j <= n; j++ {
			ans[i] = (ans[i] - basis[i][j]*ans[j]) % P
			if ans[i] < 0 {
				ans[i] += P
			}
		}
	}

	fmt.Print("! ")
	for i := 1; i <= n; i++ {
		fmt.Print(ans[i])
	}
	fmt.Println()
}