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.*;

public class Main {

    public static void main(String[] args) throws Exception {
        System.out.println(new Main().solve(new Scanner(System.in)));
    }

    public String solve(Scanner sc){
        int n=sc.nextInt(), m=sc.nextInt();
        List<List<Integer>> adj = new ArrayList<>();
        for(int i=0; i<=n; i++) adj.add(new ArrayList<>());
        for(int i=0; i<m; i++){
            int s=sc.nextInt(), e=sc.nextInt();
            adj.get(s).add(e);
        }

        int[] vis = new int[n+1];
        List<int[]> cycle = new ArrayList<>();
        for(int i=1; i<n; i++){
            if(vis[i]==0)
                dfs(adj, i, vis, cycle);
        }
        if(cycle.size()==0) return "YES";
        for(int[] cy : cycle){
            if(traverse(adj, n, cy)) return "YES";
        }
        return "NO";
    }

    private boolean traverse(List<List<Integer>> adj, int n, int[] cy){
        int[] vis1 = new int[n+1];
        for(int i=1; i<n; i++) {
            if (vis1[i]==0&&!dfs1(adj, i, vis1, cy)) {
                return false;
            }
        }
        return true;
    }

    private boolean dfs(List<List<Integer>> adj, int s, int[] vis, List<int[]> cycle){
        vis[s] = 1;
        for(int e : adj.get(s)){
            if(vis[e]==1) {cycle.add(new int[]{s,e}); return false;}
            if(vis[e]==0){
                if(dfs(adj, e, vis, cycle)==false) {
                    cycle.add(new int[]{s,e});
                    return false;
                }
            }
        }
        vis[s] = 2;
        return true;
    }

    private boolean dfs1(List<List<Integer>> adj, int s, int[] vis, int[] cycle){
        vis[s] = 1;
        for(int e : adj.get(s)){
            if(s==cycle[0]&&e==cycle[1]) {continue;}
            if(vis[e]==1) return false;
            if(vis[e]==0){
                if(dfs1(adj, e, vis, cycle)==false) {
                    return false;
                }
            }
        }
        vis[s] = 2;
        return true;
    }

}
