For problem statement at 1000-1999/1700-1799/1710-1719/1717/problemF.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1710-1719/1717/verifierF.go ends with  can you fix the verifier? package main

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

type Edge struct {
	to   int
	cap  int
	flow int
	rev  int
}

var (
	graph [][]Edge
	level []int
	ptr   []int
)

func addEdge(from, to, cap int) {
	graph[from] = append(graph[from], Edge{to, cap, 0, len(graph[to])})
	graph[to] = append(graph[to], Edge{from, 0, 0, len(graph[from]) - 1})
}

func bfs(s, t int) bool {
	for i := range level {
		level[i] = -1
	}
	level[s] = 0
	q := make([]int, 0, len(level))
	q = append(q, s)
	for len(q) > 0 {
		v := q[0]
		q = q[1:]
		for _, e := range graph[v] {
			if e.cap-e.flow > 0 && level[e.to] == -1 {
				level[e.to] = level[v] + 1
				q = append(q, e.to)
			}
		}
	}
	return level[t] != -1
}

func dfs(v, t, pushed int) int {
	if pushed == 0 {
		return 0
	}
	if v == t {
		return pushed
	}
	for cid := ptr[v]; cid < len(graph[v]); cid++ {
		ptr[v] = cid
		e := graph[v][cid]
		tr := e.to
		if level[v]+1 != level[tr] || e.cap-e.flow == 0 {
			continue
		}
		push := pushed
		if e.cap-e.flow < push {
			push = e.cap - e.flow
		}
		pushedFlow := dfs(tr, t, push)
		if pushedFlow == 0 {
			continue
		}
		graph[v][cid].flow += pushedFlow
		graph[tr][e.rev].flow -= pushedFlow
		return pushedFlow
	}
	return 0
}

func dinic(s, t int) int {
	flow := 0
	for bfs(s, t) {
		for i := range ptr {
			ptr[i] = 0
		}
		for {
			pushed := dfs(s, t, 1000000000)
			if pushed == 0 {
				break
			}
			flow += pushed
		}
	}
	return flow
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, m int
	if _, err := fmt.Fscan(reader, &n, &m); err != nil {
		return
	}

	s := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &s[i])
	}

	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	u := make([]int, m+1)
	v := make([]int, m+1)
	deg := make([]int, n+1)
	for i := 1; i <= m; i++ {
		fmt.Fscan(reader, &u[i], &v[i])
		deg[u[i]]++
		deg[v[i]]++
	}

	numNodes := m + n + 4
	graph = make([][]Edge, numNodes)
	level = make([]int, numNodes)
	ptr = make([]int, numNodes)

	SS := 0
	TT := 1
	S := 2
	T := 3

	for i := 1; i <= m; i++ {
		addEdge(SS, 3+i, 1)
		addEdge(S, TT, 1)
		addEdge(3+i, m+3+u[i], 1)
		addEdge(3+i, m+3+v[i], 1)
	}

	sumReq := 0
	for i := 1; i <= n; i++ {
		if s[i] == 1 {
			if (deg[i]+a[i])%2 != 0 || deg[i]+a[i] < 0 || (deg[i]+a[i])/2 > deg[i] {
				fmt.Println("NO")
				return
			}
			req := (deg[i] + a[i]) / 2
			addEdge(SS, T, req)
			addEdge(m+3+i, TT, req)
			sumReq += req
		} else {
			addEdge(m+3+i, T, 1000000000)
		}
	}
	addEdge(T, S, 1000000000)

	expectedFlow := m + sumReq
	actualFlow := dinic(SS, TT)

	if actualFlow != expectedFlow {
		fmt.Println("NO")
		return
	}

	fmt.Println("YES")
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()
	for i := 1; i <= m; i++ {
		eNode := 3 + i
		for _, edge := range graph[eNode] {
			if edge.to == m+3+u[i] && edge.flow == 1 {
				fmt.Fprintln(writer, v[i], u[i])
				break
			} else if edge.to == m+3+v[i] && edge.flow == 1 {
				fmt.Fprintln(writer, u[i], v[i])
				break
			}
		}
	}
}