For problem statement at 1000-1999/1400-1499/1470-1479/1473/problemF.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1470-1479/1473/verifierF.go ends with All tests passed can you fix the verifier? ```go
package main

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

const INF int64 = 1 << 60

type Edge struct {
	to   int
	next int
	cap  int64
}

type Dinic struct {
	n     int
	head  []int
	level []int
	cur   []int
	q     []int
	edges []Edge
}

func NewDinic(n, m int) *Dinic {
	head := make([]int, n)
	for i := range head {
		head[i] = -1
	}
	return &Dinic{
		n:     n,
		head:  head,
		level: make([]int, n),
		cur:   make([]int, n),
		q:     make([]int, n),
		edges: make([]Edge, 0, m),
	}
}

func (d *Dinic) AddEdge(u, v int, c int64) {
	d.edges = append(d.edges, Edge{to: v, next: d.head[u], cap: c})
	d.head[u] = len(d.edges) - 1
	d.edges = append(d.edges, Edge{to: u, next: d.head[v], cap: 0})
	d.head[v] = len(d.edges) - 1
}

func (d *Dinic) bfs(s, t int) bool {
	for i := 0; i < d.n; i++ {
		d.level[i] = -1
	}
	h, r := 0, 0
	d.q[r] = s
	r++
	d.level[s] = 0
	for h < r {
		v := d.q[h]
		h++
		for e := d.head[v]; e != -1; e = d.edges[e].next {
			if d.edges[e].cap > 0 {
				to := d.edges[e].to
				if d.level[to] == -1 {
					d.level[to] = d.level[v] + 1
					d.q[r] = to
					r++
				}
			}
		}
	}
	return d.level[t] != -1
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func (d *Dinic) dfs(v, t int, f int64) int64 {
	if v == t || f == 0 {
		return f
	}
	for d.cur[v] != -1 {
		e := d.cur[v]
		to := d.edges[e].to
		if d.edges[e].cap > 0 && d.level[to] == d.level[v]+1 {
			pushed := d.dfs(to, t, min64(f, d.edges[e].cap))
			if pushed > 0 {
				d.edges[e].cap -= pushed
				d.edges[e^1].cap += pushed
				return pushed
			}
		}
		d.cur[v] = d.edges[e].next
	}
	return 0
}

func (d *Dinic) MaxFlow(s, t int) int64 {
	var flow int64
	for d.bfs(s, t) {
		copy(d.cur, d.head)
		for {
			pushed := d.dfs(s, t, INF)
			if pushed == 0 {
				break
			}
			flow += pushed
		}
	}
	return flow
}

func nextInt(data []byte, idx *int) int {
	n := len(data)
	i := *idx
	for i < n && data[i] <= ' ' {
		i++
	}
	sign := 1
	if data[i] == '-' {
		sign = -1
		i++
	}
	val := 0
	for i < n && data[i] >= '0' && data[i] <= '9' {
		val = val*10 + int(data[i]-'0')
		i++
	}
	*idx = i
	return sign * val
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	n := nextInt(data, &p)

	a := make([]int, n+1)
	b := make([]int64, n+1)
	lists := make([][]int, 101)

	for i := 1; i <= n; i++ {
		a[i] = nextInt(data, &p)
		lists[a[i]] = append(lists[a[i]], i)
	}
	for i := 1; i <= n; i++ {
		b[i] = int64(nextInt(data, &p))
	}

	divs := make([][]int, 101)
	for v := 1; v <= 100; v++ {
		for d := 1; d <= v; d++ {
			if v%d == 0 {
				divs[v] = append(divs[v], d)
			}
		}
	}

	aux := make([][]int, 101)
	id := n
	for v := 1; v <= 100; v++ {
		m := len(lists[v])
		aux[v] = make([]int, m+1)
		for k := 1; k <= m; k++ {
			id++
			aux[v][k] = id
		}
	}

	s := id + 1
	t := id + 2
	total := t

	g := NewDinic(total+1, 100000)

	var posSum int64
	for i := 1; i <= n; i++ {
		if b[i] > 0 {
			g.AddEdge(s, i, b[i])
			posSum += b[i]
		} else if b[i] < 0 {
			g.AddEdge(i, t, -b[i])
		}
	}

	for v := 1; v <= 100; v++ {
		for k, idx := range lists[v] {
			g.AddEdge(aux[v][k+1], idx, INF)
		}
	}

	cnt := make([]int, 101)
	for i := 1; i <= n; i++ {
		v := a[i]
		for _, d := range divs[v] {
			k := cnt[d]
			if k > 0 {
				g.AddEdge(i, aux[d][k], INF)
			}
		}
		cnt[v]++
	}

	flow := g.MaxFlow(s, t)
	ans := posSum - flow

	out := bufio.NewWriterSize(os.Stdout, 32)
	out.WriteString(strconv.FormatInt(ans, 10))
	out.WriteByte('\n')
	out.Flush()
}
```