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

public class P915D {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);

    int n = input.nextInt();
    int m = input.nextInt();

    Map<Integer, List<Integer>> edges = new HashMap<>();

    for (int i = 1; i <= n; i++) {
      edges.put(i, new ArrayList<>());
    }

    for (int i = 0; i < m; i++) {
      int a = input.nextInt();
      int b = input.nextInt();

      edges.get(a).add(b);
    }

    boolean[] visited = new boolean[n + 1];
    List<Integer> path = new ArrayList<>();
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 1; i <= n; i++) {
      int loop = dfs(i, edges, visited, path, map);
      if (loop != 0) {
        int start = map.get(loop);
        for (int j = start; j < path.size(); j++) {
          int a = path.get(j);
          int b = path.get((j + 1) == path.size() ? start : j + 1);
          final List<Integer> neighbours = edges.get(a);
          neighbours.remove(neighbours.indexOf(b));
          boolean[] visited2 = new boolean[n + 1];
          List<Integer> path2 = new ArrayList<>();
          Map<Integer, Integer> map2 = new HashMap<>();
          boolean isCyclic = false;
          for (int k = 1; k <= n; k++) {
            if (dfs(k, edges, visited2, path2, map2) != 0) {
              isCyclic = true;
              break;
            }
          }
          if (!isCyclic) {
            System.out.println("YES");
            return;
          }
          neighbours.add(b);
        }
        System.out.println("NO");
        return;
      }
    }

    System.out.println("YES");
  }

  private static int dfs(int start, Map<Integer, List<Integer>> edges, boolean[] visited, List<Integer> path, Map<Integer, Integer> map) {
    if (!visited[start]) {
      visited[start] = true;
      path.add(start);
      map.put(start, path.size() - 1);

      final List<Integer> neighbours = edges.get(start);

      for (int i = 0; i < neighbours.size(); i++) {
        int b = neighbours.get(i);
        int loop;
        if (!visited[b] && (loop = dfs(b, edges, visited, path, map)) != 0) {
          return loop;
        } else if (map.containsKey(b)) {
          return b;
        }
      }
      path.remove((int)map.remove(start));
    }

    return 0;
  }

}