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.awt.Point;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;

public class Main {
	
	static int V;
	static Stack<Point> cutEdges;
	static LinkedList<Integer>[] adj;
	
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		
		V = input.nextInt();
		int M = input.nextInt();
		
		adj = new LinkedList[V];
		for (int i = 0; i < V; i++)
			adj[i] = new LinkedList<Integer>();
		
		for (int i = 0; i < M; i++)
			adj[input.nextInt() - 1].add(input.nextInt() - 1);
		
		cutEdges = new Stack<Point>();
		
		boolean found = cycle(true);
		while (!cutEdges.isEmpty() && found) {
			Point edge = cutEdges.pop();
			int u = edge.x, v = edge.y;
			adj[u].remove((Integer) v);
			if (!cycle(false))
				found = false;
			adj[u].add(v);
		}
		
		if (!found)
			System.out.println("YES");
		else
			System.out.println("NO");
	}
	

	static boolean cycle(boolean first) {
		boolean[] visited = new boolean[V];
		boolean[] onstack = new boolean[V];
		boolean hasCycle = false;
		for (int i = 0; i < V && !hasCycle; i++)
			if (!visited[i])
				hasCycle |= dfs(first, i, visited, onstack, cutEdges);
		return hasCycle;
	}
	
	static boolean dfs(boolean first, int v, boolean[] visited, boolean[] onstack, Stack<Point> edges) {
		if (!visited[v]) {
			onstack[v] = visited[v] = true;
			for (int w : adj[v]) {
				if (first) edges.add(new Point(v, w));
				if (!visited[w] && dfs(first, w, visited, onstack, edges))
					return true;
				else if (onstack[w])
					return true;
				if (first) edges.pop();
			}
		}
		
		onstack[v] = false;
		return false;
	}
}
