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.*;
import java.io.*;
import java.awt.Point;
public class p915D 
{
	static Set<Integer>[] list;
	static int[] visited;
	static List<Point> edges;
	public static void main(String[] args) throws IOException 
	{
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		StringTokenizer st = new StringTokenizer(f.readLine());
		int n = Integer.parseInt(st.nextToken()), m = Integer.parseInt(st.nextToken());
		list = new HashSet[n + 1];
		for(int i = 1; i <= n; i++)
			list[i] = new HashSet<Integer>();
		while(m-- > 0)
		{
			st = new StringTokenizer(f.readLine());
			int u = Integer.parseInt(st.nextToken());
			int v = Integer.parseInt(st.nextToken());
			list[u].add(v);
		}
		edges = new LinkedList<Point>();
		if(check(true))
			out.println("YES");
		else
		{
			for(Point p : edges)
			{
				list[p.x].remove(p.y);
				if(check(false))
				{
					out.println("YES");
					out.close();
					return;
				}
				list[p.x].add(p.y);
			}
			out.println("NO");
		}
		out.close();
	}
	
	static boolean check(boolean flag)
	{
		visited = new int[list.length];
		for(int i = 1; i < list.length; i++)
			if(visited[i] == 0)
				if(dfs(i, flag))
					return false;
		return true;
	}
	
	static boolean dfs(int u, boolean flag)
	{
		if(visited[u] == 1)
			return true;
		visited[u] = 1;
		for(int v : list[u])
			if(visited[v] != 2 && dfs(v, flag))
			{
				if(flag)
					edges.add(new Point(u, v));
				return true;
			}
		visited[u] = 2;
		return false;
	}
	
}