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.
/**
 * DA-IICT
 * Author : Savaliya Sagar
 */
import java.io.*;
import java.math.*;
import java.util.*;


public class D915
{
	int v[];
	HashSet<Integer> a[];
	ArrayList<Integer> cycle = new ArrayList<>();
	int rs[];
	int flag = 0;
	void solve()
	{
		int n = ni();
		int m = ni();
		a = new HashSet[n + 1];
		v = new int[n+1];
		rs = new int[n+1];
		for (int i = 0; i <= n; i++)
		{
			a[i] = new HashSet<>();
		}
		for (int i = 0; i < m; i++)
		{
			int u = ni();
			int v = ni();
			a[u].add(v);
		}
		for(int i=1;i<=n;i++) {
			if(v[i]==0) {
				int x = dfs(i);
				if(x==0)
					break;
			}
		}
		if(cycle.isEmpty()) {
			out.println("YES");
			return;
		}
		cycle.add(cycle.get(0));
		for(int i=cycle.size()-1;i>0;i--) {
			int uu = cycle.get(i);
			int vv = cycle.get(i-1);
			a[uu].remove(vv);
			Arrays.fill(v, 0);
			Arrays.fill(rs, 0);
			boolean havecycle = false;
			for(int j=1;j<=n;j++) {
				if(v[j]==0) {
					int x = dfs(j);
					if(x==0)
					{
						havecycle = true;
						break;
					}
				}
			}
			a[uu].add(vv);
			if(!havecycle) {
				out.println("YES");
				return;
			}
		}
		out.println("NO");
	}
	public int dfs(int u){
		if(rs[u]==1) {
			cycle.add(u);
			return u;
		}
		if(v[u]==1)
			return -1;
		v[u] = 1;
		rs[u] = 1;
		int ret = -1;
		for(int k:a[u]) {
			int d = dfs(k);
			if(d==-1)
				continue;
			if(d==0 || d==u) {
				ret = 0;
				break;
			}
			ret = d;
			cycle.add(u);
			break;
		}
		rs[u] = 0;
		return ret;
	}
	public int ni()
	{
		return Integer.parseInt(next());
	}
	private void tr(Object... o)
	{
		if (debug == 1)
			System.out.println(Arrays.deepToString(o));
	}
	
	int debug = 1;
	void run() throws Exception
	{
		out = new PrintWriter(System.out);
		reader = new BufferedReader(new InputStreamReader(System.in), 32768);
		tokenizer = null;
		solve();
		out.flush();
	}
	
	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter out;
	
	public static void main(String[] args) throws Exception
	{
		new Thread(null, new Runnable()
		{
			public void run()
			{
				try
				{
					new D915().run();
				} catch (Exception e)
				{
					e.printStackTrace();
				}
			}
		}, "1", 1 << 26).start();
	}
	
	public String next()
	{
		while (tokenizer == null || !tokenizer.hasMoreTokens())
		{
			try
			{
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e)
			{
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
}
