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 java.util.*;
import java.io.*;

public class P915D
{
    private static class Edge
    {
        int from;
        int to;
        int next;
    }

    private static int cnt = 0;

    private static void dfs(int now, int[] visited, int[] head, Edge[] edges)
    {
        if(cnt >= 2)
        {
            return;
        }

        visited[now] = 1;
        for(int i = head[now]; i != -1; i = edges[i].next)
        {
            int t = edges[i].to;
            if(visited[t] == 0)
            {
                dfs(t, visited, head, edges);
            }
            else if(visited[t] == 1)
            {
                cnt += 1;
            }
        }
        visited[now] = 2;
    }

    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        int m = in.nextInt();
        Edge[] edges = new Edge[m];
        int[] head = new int[n];
        Arrays.fill(head, -1);
        for(int i = 0; i < m; ++i)
        {
            int s = in.nextInt() - 1;
            int t = in.nextInt() - 1;
            edges[i] = new Edge();
            edges[i].from = s;
            edges[i].to = t;
            edges[i].next = head[s];
            head[s] = i;
        }

        boolean can = false;
        int[] visited = new int[n];
        for(int i = 0; i < n; ++i)
        {
            cnt = 0;
            Arrays.fill(visited, 0);
            dfs(i, visited, head, edges);
            for(int j = 0; j < n; ++j)
            {
                if(visited[j] == 0)
                {
                    dfs(j, visited, head, edges);
                }
            }
            if(cnt <= 1)
            {
                can = true;
                break;
            }
        }

        if(can)
        {
            out.println("YES");
        }
        else
        {
            out.println("NO");
        }

        out.close();
    }
}
