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.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    static Set<String> edges = new HashSet();
    static Set<Integer> vis = new HashSet();

    public static boolean findEdgesFormingCircle(int u, int graph[][], boolean visited[]){
        for(int i=1;i<graph.length;i++){
            if(graph[u][i]==1) {
                if (!visited[i]) {
                    visited[i] = true;
                    edges.add(u + " " + i);
                    vis.add(i);
                    boolean cyc = findEdgesFormingCircle(i, graph, visited);
                    if (cyc) {
                        return true;
                    }
                    vis.remove(i);
                    edges.remove(u + " " + i);
                    vis.remove(i);
                }
                else if (vis.contains(i)) {
                    edges.add(u+" "+i);
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean containsCycle(int u, int graph[][], boolean visited[]){
        for(int i=1;i<graph.length;i++){
            if(graph[u][i]==1){
                if(!visited[i]){
                    visited[i] = true;
                    vis.add(i);
                    boolean c = containsCycle(i,graph,visited);
                    if(c){
                        return true;
                    }
                    vis.remove(i);
                }
                else if(vis.contains(i)){
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner obj = new Scanner(System.in);
        int n = obj.nextInt();
        int m = obj.nextInt();
        int graph[][] = new int[n+1][n+1];
        for(int i=0;i<m;i++){
            int x = obj.nextInt();
            int y = obj.nextInt();
            graph[x][y] = 1;
        }
        boolean visited[] = new boolean[n+1];
        boolean cyc = false;
        for(int i=1;i<=n;i++){
            if(!visited[i]){
                visited[i] = true;
                vis.add(i);
                cyc = findEdgesFormingCircle(i,graph,visited);
                if(cyc){
                    break;
                }
                vis.remove(i);
            }
        }
        if(!cyc){
            System.out.println("YES");
            return;
        }

//        System.out.println(edges);
        for(String e : edges){
//            System.out.println("Remove "+e);
            String uv[] = e.split(" ");
            int u = Integer.parseInt(uv[0]);
            int v = Integer.parseInt(uv[1]);
            graph[u][v] = 0;
            visited = new boolean[n+1];
            cyc = false;
            vis.clear();
            for(int i=1;i<=n;i++){
//                System.out.println("Check circle with "+i);
                if(!visited[i]) {
                    visited[i] = true;
                    vis.add(i);
                    cyc = cyc || containsCycle(i, graph, visited);
                    if(cyc){
//                        System.out.println("Cycle Present");
                        graph[u][v] = 1;
                        break;
                    }
                    vis.remove(i);
                }
            }
            if(!cyc){
                System.out.println("YES");
                return;
            }
            graph[u][v] = 1;
        }
        System.out.println("NO");
    }
}
