For problem statement at 0-999/900-999/990-999/993/problemF.txt this is a correct solution, but verifier at 0-999/900-999/990-999/993/verifierF.go ends with All tests passed! can you fix the verifier? package main

import (
	"fmt"
)

type Gate struct {
	op   string
	c, d int
}

func eval(op string, a, b int) int {
	switch op {
	case "and":
		return a & b
	case "or":
		return a | b
	case "nand":
		return 1 - (a & b)
	case "nor":
		return 1 - (a | b)
	}
	return 0
}

func getInputs(s string) (int, int) {
	var c, d int
	first := true
	for i, ch := range s {
		if ch == 'x' {
			if first {
				c = i
				first = false
			} else {
				d = i
			}
		}
	}
	return c, d
}

var n, m, k int
var l1 []Gate
var l2 []Gate
var maxValid int = -1

func checkCond2(R []int) bool {
	req := make([]int, m)
	for i := range req {
		req[i] = -1
	}
	for _, idx := range R {
		g := l2[idx]
		v := 0
		if g.op == "nand" || g.op == "nor" {
			v = 1
		}
		for _, c := range []int{g.c, g.d} {
			if req[c] != -1 && req[c] != v {
				return true
			}
			req[c] = v
		}
	}

	involved := make([]bool, n)
	for i, r := range req {
		if r != -1 {
			involved[l1[i].c] = true
			involved[l1[i].d] = true
		}
	}
	var vars []int
	for i := 0; i < n; i++ {
		if involved[i] {
			vars = append(vars, i)
		}
	}

	x := make([]int, n)
	for i := range x {
		x[i] = -1
	}

	var solve func(idx int) bool
	solve = func(idx int) bool {
		for i, r := range req {
			if r != -1 {
				g1 := l1[i]
				va, vb := x[g1.c], x[g1.d]
				if va != -1 && vb != -1 {
					if eval(g1.op, va, vb) != r {
						return false
					}
				}
			}
		}
		if idx == len(vars) {
			return true
		}
		v := vars[idx]
		x[v] = 0
		if solve(idx + 1) {
			return true
		}
		x[v] = 1
		if solve(idx + 1) {
			return true
		}
		x[v] = -1
		return false
	}

	return !solve(0)
}

func intersect(a, b []int) []int {
	m := make(map[int]bool)
	for _, v := range a {
		m[v] = true
	}
	var res []int
	for _, v := range b {
		if m[v] {
			res = append(res, v)
		}
	}
	return res
}

func remove(s []int, v int) []int {
	var res []int
	for _, x := range s {
		if x != v {
			res = append(res, x)
		}
	}
	return res
}

var adj [][]int

func bk(R, P, X []int) {
	if len(P) == 0 && len(X) == 0 {
		if len(R) > 0 && checkCond2(R) {
			if len(R) > maxValid {
				maxValid = len(R)
			}
		}
		return
	}
	P_copy := append([]int(nil), P...)
	for _, v := range P_copy {
		nR := append(append([]int(nil), R...), v)
		nP := intersect(P, adj[v])
		nX := intersect(X, adj[v])
		bk(nR, nP, nX)
		P = remove(P, v)
		X = append(X, v)
	}
}

func main() {
	if _, err := fmt.Scan(&n, &m, &k); err != nil {
		return
	}

	l1 = make([]Gate, m)
	for i := 0; i < m; i++ {
		var op, s string
		fmt.Scan(&op, &s)
		c, d := getInputs(s)
		l1[i] = Gate{op, c, d}
	}

	l2 = make([]Gate, k)
	for i := 0; i < k; i++ {
		var op, s string
		fmt.Scan(&op, &s)
		c, d := getInputs(s)
		l2[i] = Gate{op, c, d}
	}

	validEdge := func(i, j int) bool {
		gI := l2[i]
		gJ := l2[j]
		varsMap := make(map[int]bool)
		for _, idx := range []int{gI.c, gI.d, gJ.c, gJ.d} {
			varsMap[l1[idx].c] = true
			varsMap[l1[idx].d] = true
		}
		var vars []int
		for v := range varsMap {
			vars = append(vars, v)
		}

		numVars := len(vars)
		for mask := 0; mask < (1 << numVars); mask++ {
			x := make([]int, n)
			for bit := 0; bit < numVars; bit++ {
				if (mask & (1 << bit)) != 0 {
					x[vars[bit]] = 1
				} else {
					x[vars[bit]] = 0
				}
			}

			evalG := func(idx int, normal bool) int {
				g := l1[idx]
				res := eval(g.op, x[g.c], x[g.d])
				if normal {
					return res
				}
				return 1 - res
			}

			pi := eval(gI.op, evalG(gI.c, true), evalG(gI.d, true))
			qj := eval(gJ.op, evalG(gJ.c, false), evalG(gJ.d, false))
			if pi == 1 && qj == 0 {
				return false
			}
		}
		return true
	}

	adj = make([][]int, k)
	for i := 0; i < k; i++ {
		if !validEdge(i, i) {
			continue
		}
		for j := i + 1; j < k; j++ {
			if !validEdge(j, j) {
				continue
			}
			if validEdge(i, j) && validEdge(j, i) {
				adj[i] = append(adj[i], j)
				adj[j] = append(adj[j], i)
			}
		}
	}

	var P []int
	for i := 0; i < k; i++ {
		if validEdge(i, i) {
			P = append(P, i)
		}
	}

	bk([]int{}, P, []int{})

	if maxValid == -1 {
		fmt.Println("-1")
	} else {
		fmt.Println(k - maxValid)
	}
}