For problem statement at 0-999/500-599/570-579/575/problemB.txt this is a correct solution, but verifier at 0-999/500-599/570-579/575/verifierB.go ends with reference failed: exec: "refB_bin": executable file not found in $PATH can you fix the verifier? package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

const MOD int64 = 1000000007

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if (c >= '0' && c <= '9') || c == '-' {
			break
		}
		fs.idx++
	}
	if fs.idx >= fs.n {
		return 0
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return sign * val
}

func main() {
	fs := NewFastScanner()

	n := fs.NextInt()

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

	m := 2 * (n - 1)
	to := make([]int, m)
	next := make([]int, m)
	typ := make([]byte, m)
	edgePtr := 0

	addEdge := func(u, v int, t byte) {
		to[edgePtr] = v
		typ[edgePtr] = t
		next[edgePtr] = head[u]
		head[u] = edgePtr
		edgePtr++
	}

	for i := 0; i < n-1; i++ {
		a := fs.NextInt()
		b := fs.NextInt()
		x := fs.NextInt()
		if x == 0 {
			addEdge(a, b, 0)
			addEdge(b, a, 0)
		} else {
			addEdge(a, b, 1)
			addEdge(b, a, 2)
		}
	}

	parent := make([]int, n+1)
	depth := make([]int, n+1)
	legal := make([]byte, n+1)
	order := make([]int, 0, n)
	order = append(order, 1)

	for i := 0; i < len(order); i++ {
		u := order[i]
		for e := head[u]; e != -1; e = next[e] {
			v := to[e]
			if v == parent[u] {
				continue
			}
			parent[v] = u
			depth[v] = depth[u] + 1
			legal[v] = typ[e]
			order = append(order, v)
		}
	}

	log := 0
	for (1 << log) <= n {
		log++
	}

	up := make([][]int, log)
	up[0] = parent
	for j := 1; j < log; j++ {
		prev := up[j-1]
		cur := make([]int, n+1)
		for v := 1; v <= n; v++ {
			cur[v] = prev[prev[v]]
		}
		up[j] = cur
	}

	lca := func(u, v int) int {
		if depth[u] < depth[v] {
			u, v = v, u
		}
		diff := depth[u] - depth[v]
		bit := 0
		for diff > 0 {
			if diff&1 == 1 {
				u = up[bit][u]
			}
			diff >>= 1
			bit++
		}
		if u == v {
			return u
		}
		for j := log - 1; j >= 0; j-- {
			if up[j][u] != up[j][v] {
				u = up[j][u]
				v = up[j][v]
			}
		}
		return parent[u]
	}

	k := fs.NextInt()

	pow2 := make([]int64, k+1)
	pow2[0] = 1
	for i := 1; i <= k; i++ {
		pow2[i] = (pow2[i-1] * 2) % MOD
	}

	upDiff := make([]int, n+1)
	downDiff := make([]int, n+1)

	prevNode := 1
	for i := 0; i < k; i++ {
		s := fs.NextInt()
		l := lca(prevNode, s)
		upDiff[prevNode]++
		upDiff[l]--
		downDiff[s]++
		downDiff[l]--
		prevNode = s
	}

	var ans int64
	for i := len(order) - 1; i >= 1; i-- {
		u := order[i]

		if legal[u] == 1 {
			c := upDiff[u]
			if c > 0 {
				ans += pow2[c] - 1
			}
		} else if legal[u] == 2 {
			c := downDiff[u]
			if c > 0 {
				ans += pow2[c] - 1
			}
		}

		p := parent[u]
		upDiff[p] += upDiff[u]
		downDiff[p] += downDiff[u]
	}

	ans %= MOD

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	out.WriteString(strconv.FormatInt(ans, 10))
	out.Flush()
}