For problem statement at 0-999/800-899/800-809/808/problemF.txt this is a correct solution, but verifier at 0-999/800-899/800-809/808/verifierF.go ends with All 100 tests passed can you fix the verifier? package main

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

type Edge struct {
	to  int
	rev int
	cap int64
}

type Dinic struct {
	g     [][]Edge
	level []int
	it    []int
}

func NewDinic(n int) *Dinic {
	return &Dinic{
		g:     make([][]Edge, n),
		level: make([]int, n),
		it:    make([]int, n),
	}
}

func (d *Dinic) AddEdge(from, to int, cap int64) {
	fwd := Edge{to: to, rev: len(d.g[to]), cap: cap}
	rev := Edge{to: from, rev: len(d.g[from]), cap: 0}
	d.g[from] = append(d.g[from], fwd)
	d.g[to] = append(d.g[to], rev)
}

func (d *Dinic) bfs(s, t int) bool {
	for i := range d.level {
		d.level[i] = -1
	}
	q := make([]int, 0, len(d.g))
	d.level[s] = 0
	q = append(q, s)
	for head := 0; head < len(q); head++ {
		v := q[head]
		for _, e := range d.g[v] {
			if e.cap > 0 && d.level[e.to] < 0 {
				d.level[e.to] = d.level[v] + 1
				q = append(q, e.to)
			}
		}
	}
	return d.level[t] >= 0
}

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 {
		return f
	}
	for ; d.it[v] < len(d.g[v]); d.it[v]++ {
		i := d.it[v]
		e := &d.g[v][i]
		if e.cap > 0 && d.level[v] < d.level[e.to] {
			ret := d.dfs(e.to, t, min64(f, e.cap))
			if ret > 0 {
				e.cap -= ret
				d.g[e.to][e.rev].cap += ret
				return ret
			}
		}
	}
	return 0
}

func (d *Dinic) MaxFlow(s, t int) int64 {
	var flow int64
	const inf int64 = 1 << 60
	for d.bfs(s, t) {
		for i := range d.it {
			d.it[i] = 0
		}
		for {
			f := d.dfs(s, t, inf)
			if f == 0 {
				break
			}
			flow += f
		}
	}
	return flow
}

func maxIndependentSetWeight(odd, even []int, p []int, conflict [][]bool) int64 {
	o := len(odd)
	e := len(even)
	s := 0
	t := o + e + 1
	d := NewDinic(t + 1)
	var total int64
	const inf int64 = 1 << 60

	for i, idx := range odd {
		w := int64(p[idx])
		total += w
		d.AddEdge(s, 1+i, w)
	}
	for j, idx := range even {
		w := int64(p[idx])
		total += w
		d.AddEdge(1+o+j, t, w)
	}
	for i, oi := range odd {
		for j, ej := range even {
			if conflict[oi][ej] {
				d.AddEdge(1+i, 1+o+j, inf)
			}
		}
	}
	return total - d.MaxFlow(s, t)
}

func maxPowerAtLevel(L int, n int, p, c, lvl []int, isPrime []bool, conflict [][]bool) int64 {
	odd := make([]int, 0)
	even := make([]int, 0)
	bestOne := 0

	for i := 0; i < n; i++ {
		if lvl[i] > L {
			continue
		}
		if c[i] == 1 {
			if p[i] > bestOne {
				bestOne = p[i]
			}
		} else if c[i]%2 == 1 {
			odd = append(odd, i)
		} else {
			even = append(even, i)
		}
	}

	best := maxIndependentSetWeight(odd, even, p, conflict)

	if bestOne > 0 {
		even2 := make([]int, 0, len(even))
		for _, idx := range even {
			if !isPrime[c[idx]+1] {
				even2 = append(even2, idx)
			}
		}
		v := int64(bestOne) + maxIndependentSetWeight(odd, even2, p, conflict)
		if v > best {
			best = v
		}
	}

	return best
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n, k int
	fmt.Fscan(in, &n, &k)

	p := make([]int, n)
	c := make([]int, n)
	lvl := make([]int, n)

	maxC := 0
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &p[i], &c[i], &lvl[i])
		if c[i] > maxC {
			maxC = c[i]
		}
	}

	limit := 2 * maxC
	if limit < 2 {
		limit = 2
	}
	isPrime := make([]bool, limit+1)
	for i := 2; i <= limit; i++ {
		isPrime[i] = true
	}
	for i := 2; i*i <= limit; i++ {
		if isPrime[i] {
			for j := i * i; j <= limit; j += i {
				isPrime[j] = false
			}
		}
	}

	conflict := make([][]bool, n)
	for i := 0; i < n; i++ {
		conflict[i] = make([]bool, n)
		for j := 0; j < n; j++ {
			if isPrime[c[i]+c[j]] {
				conflict[i][j] = true
			}
		}
	}

	ans := -1
	for L := 1; L <= n; L++ {
		if maxPowerAtLevel(L, n, p, c, lvl, isPrime, conflict) >= int64(k) {
			ans = L
			break
		}
	}

	fmt.Fprintln(out, ans)
}