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.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class MAIN {
    
    ArrayList<Integer> graph[];
    boolean ans = true;
    boolean vis[];
    boolean stack[];
    int cnt = 0;
    
    void Run()
    {
        Scanner IN = new Scanner(System.in);
        int n = IN.nextInt();
        int m = IN.nextInt();
        graph = new ArrayList[n+2];
        for(int i=1;i<=n;i++) graph[i] = new ArrayList<>();
        
        while(m-->0)
        {
            int u = IN.nextInt();
            int v = IN.nextInt();
            graph[u].add(v);
        }
        
        vis   = new boolean[n+2];
        stack = new boolean[n+2];
        
        for(int i=1;i<=n;i++)
        {
            Arrays.fill(vis, false);
            cnt = 0;
            dfs(i);
            for(int j=1;j<=n;j++)
            {
                if( !vis[j] ) dfs(j);
            }
            if( cnt<=1 )
            {
                System.out.println("YES");
                return ;
            }
        }
        System.out.println("NO");
    }
    
    public void dfs( int u )
    {
        vis[u] = true;
        stack[u] = true;
        for(int v : graph[u])
        {
            if( !vis[v] ) dfs(v);
            else if( stack[v] ) ++cnt;
        }
        stack[u] = false;
    }

    public static void main(String[] args) {
        
        new MAIN().Run();
        
    }
    
}

