```go
package main

import (
	"fmt"
	"io"
	"math/bits"
	"os"
)

func main() {
	buf, _ := io.ReadAll(os.Stdin)
	pos := 0

	nextInt := func() int {
		for pos < len(buf) && (buf[pos] < '0' || buf[pos] > '9') {
			pos++
		}
		if pos >= len(buf) {
			return 0
		}
		res := 0
		for pos < len(buf) && buf[pos] >= '0' && buf[pos] <= '9' {
			res = res*10 + int(buf[pos]-'0')
			pos++
		}
		return res
	}

	n := nextInt()
	m := nextInt()

	if n == 0 {
		return
	}

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

	inDegree := make([]int, n)
	outDegree := make([]int, n)

	for i := 0; i < m; i++ {
		u := nextInt() - 1
		v := nextInt() - 1
		to[i] = v
		next[i] = head[u]
		head[u] = i

		outDegree[u]++
		inDegree[v]++
	}

	var sources []int
	var sinks []int
	for i := 0; i < n; i++ {
		if inDegree[i] == 0 {
			sources = append(sources, i)
		}
		if outDegree[i] == 0 {
			sinks = append(sinks, i)
		}
	}

	k := len(sources)
	if k == 0 {
		fmt.Println("YES")
		return
	}

	sourceMask := make([]uint32, n)
	queue := make([]int, n)
	headQ, tailQ := 0, 0

	for i, s := range sources {
		sourceMask[s] = 1 << i
		queue[tailQ] = s
		tailQ++
	}

	for headQ < tailQ {
		u := queue[headQ]
		headQ++

		for e := head[u]; e != -1; e = next[e] {
			v := to[e]
			sourceMask[v] |= sourceMask[u]
			inDegree[v]--
			if inDegree[v] == 0 {
				queue[tailQ] = v
				tailQ++
			}
		}
	}

	sinkMask := make([]uint32, k)
	for j, sink := range sinks {
		sMask := sourceMask[sink]
		for i := 0; i < k; i++ {
			if (sMask & (1 << i)) != 0 {
				sinkMask[i] |= (1 << j)
			}
		}
	}

	sinksReached := make([]uint32, 1<<k)
	for x := 1; x < (1<<k)-1; x++ {
		lsb := x & -x
		idx := bits.TrailingZeros32(uint32(lsb))
		sinksReached[x] = sinksReached[x^lsb] | sinkMask[idx]

		if bits.OnesCount32(sinksReached[x]) <= bits.OnesCount32(uint32(x)) {
			fmt.Println("NO")
			return
		}
	}

	fmt.Println("YES")
}
```