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 {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt(), m=scanner.nextInt();
        ArrayList<Integer>[] lists=new ArrayList[n];
        for (int i=0;i<n;i++) lists[i]=new ArrayList<>();
        while (m-->0) {
            int x=scanner.nextInt()-1, y=scanner.nextInt()-1;
            lists[x].add(y);
        }
        System.out.println(solve(n, lists)?"YES":"NO");
    }

    private static boolean solve(int n, ArrayList<Integer>[] lists) {
        HashSet<Integer> able=null;
        for (int i=0;i<n;i++) {
            boolean[] visited=new boolean[n];
            int[] prev=new int[n];

            Queue<Integer> queue=new LinkedList<>();
            queue.add(i);
            prev[i]=-1;

            while (!queue.isEmpty()) {
                int v=queue.poll();

                for (int nxt: lists[v]) {
                    if (nxt==i) {
                        // circle!
                        HashSet<Integer> route=new HashSet<>();
                        route.add(10000*v+nxt);
                        int now=v;
                        while (prev[now]!=-1) {
                            route.add(10000*prev[now]+now);
                            now=prev[now];
                        }
                        if (able==null) able=new HashSet<>(route);
                        else {
                            merge(able, route);
                            if (able.isEmpty()) return false;
                        }
                        continue;
                    }
                    if (visited[nxt]) continue;
                    visited[nxt]=true;
                    prev[nxt]=v;
                    queue.offer(nxt);
                }
            }
        }
        return true;
    }

    private static void merge(HashSet<Integer> set1, HashSet<Integer> set2) {
        set1.removeIf(x->!set2.contains(x));
    }

}
