You are given a [directed graph](https://en.wikipedia.org/wiki/Directed_graph) consisting of n vertices and m edges (each edge is directed, so it can be traversed in only one direction). You are allowed to remove at most one edge from it.

Can you make this graph [acyclic](https://en.wikipedia.org/wiki/Directed_acyclic_graph) by removing at most one edge from it? A directed graph is called acyclic iff it doesn't contain any cycle (a non-empty path that starts and ends in the same vertex).

Input

The first line contains two integers n and m (2 ≤ n ≤ 500, 1 ≤ m ≤ min(n(n - 1), 100000)) — the number of vertices and the number of edges, respectively.

Then m lines follow. Each line contains two integers u and v denoting a directed edge going from vertex u to vertex v (1 ≤ u, v ≤ n, u ≠ v). Each ordered pair (u, v) is listed at most once (there is at most one directed edge from u to v).

Output

If it is possible to make this graph acyclic by removing at most one edge, print YES. Otherwise, print NO.

Examples

Input

3 4
1 2
2 3
3 2
3 1


Output

YES


Input

5 6
1 2
2 3
3 2
3 1
2 1
4 5


Output

NO

Note

In the first example you can remove edge <image>, and the graph becomes acyclic.

In the second example you have to remove at least two edges (for example, <image> and <image>) in order to make the graph acyclic.
import sys
range = xrange
input = raw_input

inp = [int(x) for x in sys.stdin.read().split()]; ii = 0

n = inp[ii]; ii += 1
m = inp[ii]; ii += 1

forw = [[] for _ in range(n)]
back = [[] for _ in range(n)]
for _ in range(m):
    u = inp[ii] - 1; ii += 1
    v = inp[ii] - 1; ii += 1
    forw[u].append(v)
    back[v].append(u)

outdeg = [len(f) for f in forw]
indeg = [len(f) for f in back]
found = [0]*n

def update(outdeg, indeg, found):
    rems = []
    for node in range(n):
        if not found[node] and (not outdeg[node] or not indeg[node]):
            found[node] = 1
            rems.append(node)

    for node in rems:
        for nei in forw[node]:
            indeg[nei] -= 1
            if not indeg[nei] and not found[nei]:
                found[nei] = 1
                rems.append(nei)

        for nei in back[node]:
            outdeg[nei] -= 1
            if not outdeg[nei] and not found[nei]:
                found[nei] = 1
                rems.append(nei)
    return all(found)

ans = update(outdeg, indeg, found)
if ans:
    print 'YES'
    sys.exit()

checked = list(found)
for node in range(n):
    if checked[node] or indeg[node] != 1:
        continue
    for nei in back[node]:
        if not checked[nei] and outdeg[nei] == 1:
            indeg[node] -= 1
            outdeg[nei] -= 1
            checked[node] = 1
            checked[nei] = 1

            if update(list(outdeg), list(indeg), list(found)):
                print 'YES'
                sys.exit()
            indeg[node] += 1
            outdeg[nei] += 1
print 'NO'
