915_D. Almost Acyclic Graph
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.
```python
def dfs(g, u, visited, call_stack):
    visited[u] = True
    call_stack.add(u)
    for v in g[u]:
        if v in call_stack:
            return [u, v]
        if not visited[v]:
            d = dfs(g, v, visited, call_stack)
            call_stack.discard(v)
            if d is not None:
                return [u] + d
    return None


def find_cycle(g, n):
    visited = [False] * n
    d = None
    for i in range(n):
        if not visited[i]:
            call_stack = set()
            d = dfs(g, i, visited, call_stack)
            if d is not None:
                break
    return d


if __name__ == '__main__':
    n, m = map(int, input().split())

    g = []
    for _ in range(n):
        g.append([])

    for _ in range(m):
        u, v = map(int, input().split())
        g[u-1].append(v-1)

    out = False
    c = find_cycle(g, n)
    if c:
        first_index = c.index(c[-1])
        c = c[first_index:]

        for i in range(len(c)-1):
            if i != 0:
                g[c[i-1]].append(c[i])
            g[c[i]].remove(c[i+1])
            out = out or find_cycle(g, n) is None
    else:
        out = True

    print('YES' if out else 'NO')
```