For problem statement at 1000-1999/1000-1099/1010-1019/1019/problemC.txt this is a correct solution, but verifier at 1000-1999/1000-1099/1010-1019/1019/verifierC.go ends with All tests passed can you fix the verifier? ```go
package main

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

type Scanner struct {
	buf  []byte
	pos  int
	size int
}

func NewScanner() *Scanner {
	return &Scanner{
		buf: make([]byte, 1024*1024),
	}
}

func (s *Scanner) nextInt() int {
	res := 0
	for {
		if s.pos >= s.size {
			n, err := os.Stdin.Read(s.buf)
			if err != nil && err != io.EOF {
				return 0
			}
			if n == 0 {
				return res
			}
			s.pos = 0
			s.size = n
		}
		b := s.buf[s.pos]
		s.pos++
		if b >= '0' && b <= '9' {
			res = int(b - '0')
			break
		}
	}
	for {
		if s.pos >= s.size {
			n, err := os.Stdin.Read(s.buf)
			if err != nil && err != io.EOF {
				return res
			}
			if n == 0 {
				return res
			}
			s.pos = 0
			s.size = n
		}
		b := s.buf[s.pos]
		if b >= '0' && b <= '9' {
			res = res*10 + int(b-'0')
			s.pos++
		} else {
			break
		}
	}
	return res
}

func writeInt(w *bufio.Writer, n int) {
	if n == 0 {
		w.WriteByte('0')
		return
	}
	var buf [20]byte
	i := 19
	for n > 0 {
		buf[i] = byte(n%10 + '0')
		n /= 10
		i--
	}
	w.Write(buf[i+1:])
}

func main() {
	sc := NewScanner()
	n := sc.nextInt()
	m := sc.nextInt()

	if n == 0 {
		return
	}

	headOut := make([]int, n+1)
	nextOut := make([]int, m+1)
	toOut := make([]int, m+1)

	headIn := make([]int, n+1)
	nextIn := make([]int, m+1)
	toIn := make([]int, m+1)

	for i := 1; i <= m; i++ {
		u := sc.nextInt()
		v := sc.nextInt()

		toOut[i] = v
		nextOut[i] = headOut[u]
		headOut[u] = i

		toIn[i] = u
		nextIn[i] = headIn[v]
		headIn[v] = i
	}

	alive := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		alive[i] = true
	}

	L := make([]int, 0, n)
	for i := 1; i <= n; i++ {
		if alive[i] {
			L = append(L, i)
			alive[i] = false
			for e := headOut[i]; e != 0; e = nextOut[e] {
				v := toOut[e]
				alive[v] = false
			}
		}
	}

	inQ := make([]bool, n+1)
	var Q []int

	for i := len(L) - 1; i >= 0; i-- {
		u := L[i]
		hasEdge := false
		for e := headIn[u]; e != 0; e = nextIn[e] {
			if inQ[toIn[e]] {
				hasEdge = true
				break
			}
		}
		if !hasEdge {
			inQ[u] = true
			Q = append(Q, u)
		}
	}

	out := bufio.NewWriter(os.Stdout)
	writeInt(out, len(Q))
	out.WriteByte('\n')
	for i, v := range Q {
		if i > 0 {
			out.WriteByte(' ')
		}
		writeInt(out, v)
	}
	out.WriteByte('\n')
	out.Flush()
}
```