For problem statement at 1000-1999/1600-1699/1690-1699/1697/problemF.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1690-1699/1697/verifierF.go ends with failed to build reference: exit status 1
# command-line-arguments
./1697F.go:5:4: "fmt" imported and not used

exit status 1 can you fix the verifier? ```go
package main

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

func main() {
	b, _ := io.ReadAll(os.Stdin)
	pos := 0
	nextInt := func() int {
		for pos < len(b) && b[pos] <= ' ' {
			pos++
		}
		if pos >= len(b) {
			return 0
		}
		res := 0
		for pos < len(b) && b[pos] > ' ' {
			res = res*10 + int(b[pos]-'0')
			pos++
		}
		return res
	}

	t := nextInt()
	if t == 0 {
		return
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	maxN := 20000*9 + 5
	adj := make([][]int, 2*maxN)
	dfn := make([]int, 2*maxN)
	low := make([]int, 2*maxN)
	scc := make([]int, 2*maxN)
	inStk := make([]bool, 2*maxN)
	stk := make([]int, 0, 2*maxN)

	for tc := 0; tc < t; tc++ {
		n := nextInt()
		m := nextInt()
		k := nextInt()

		nVar := n*(k-1) + 1
		nVertices := 2 * nVar

		for i := 0; i < nVertices; i++ {
			adj[i] = adj[i][:0]
			dfn[i] = 0
			low[i] = 0
			scc[i] = 0
			inStk[i] = false
		}

		addClause := func(u, v int) {
			adj[u^1] = append(adj[u^1], v)
			adj[v^1] = append(adj[v^1], u)
		}

		lit := func(i, v int) int {
			if v <= 1 {
				return 0
			}
			if v >= k+1 {
				return 1
			}
			return 2 * ((i-1)*(k-1) + v - 1)
		}

		addClause(0, 0)

		for i := 1; i <= n; i++ {
			for v := 2; v <= k; v++ {
				addClause(lit(i, v)^1, lit(i, v-1))
			}
		}

		for i := 1; i < n; i++ {
			for v := 2; v <= k; v++ {
				addClause(lit(i, v)^1, lit(i+1, v))
			}
		}

		for idx := 0; idx < m; idx++ {
			typ := nextInt()
			if typ == 1 {
				i := nextInt()
				x := nextInt()
				addClause(lit(i, x)^1, lit(i, x+1))
			} else if typ == 2 {
				i := nextInt()
				j := nextInt()
				x := nextInt()
				for u := 1; u <= k; u++ {
					addClause(lit(i, u)^1, lit(j, x-u+1)^1)
				}
			} else if typ == 3 {
				i := nextInt()
				j := nextInt()
				x := nextInt()
				for u := 1; u <= k; u++ {
					addClause(lit(j, u+1), lit(i, x-u))
				}
			}
		}

		timer := 0
		sccCnt := 0
		stk = stk[:0]

		var tarjan func(u int)
		tarjan = func(u int) {
			timer++
			dfn[u] = timer
			low[u] = timer
			stk = append(stk, u)
			inStk[u] = true
			for _, v := range adj[u] {
				if dfn[v] == 0 {
					tarjan(v)
					if low[v] < low[u] {
						low[u] = low[v]
					}
				} else if inStk[v] {
					if dfn[v] < low[u] {
						low[u] = dfn[v]
					}
				}
			}
			if low[u] == dfn[u] {
				for {
					v := stk[len(stk)-1]
					stk = stk[:len(stk)-1]
					inStk[v] = false
					scc[v] = sccCnt
					if u == v {
						break
					}
				}
				sccCnt++
			}
		}

		for i := 0; i < nVertices; i++ {
			if dfn[i] == 0 {
				tarjan(i)
			}
		}

		possible := true
		for i := 0; i < nVar; i++ {
			if scc[2*i] == scc[2*i+1] {
				possible = false
				break
			}
		}

		if !possible {
			fmt.Fprintln(out, "-1")
		} else {
			for i := 1; i <= n; i++ {
				val := 1
				for v := 2; v <= k; v++ {
					varIdx := (i-1)*(k-1) + v - 1
					if scc[2*varIdx] < scc[2*varIdx+1] {
						val = v
					}
				}
				if i > 1 {
					out.WriteByte(' ')
				}
				fmt.Fprint(out, val)
			}
			out.WriteByte('\n')
		}
	}
}
```