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.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;


public class D {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	static int[][]a;
	static int n;
	static int []color, p;
	static int[]cycle;
	static int cycleSize;
	
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		n = nextInt();
		int m = nextInt();
		a = new int[n+1][n+1];
		cycle = new int[n+1];
		for (int i = 0; i < m; i++) {
			int v1 = nextInt();
			int v2 = nextInt();
			a[v1][v2] = 1;
		}
		color = new int[n+1];
		p = new int[n+1];
		cycle = new int[n+2];
		findCycle();
		if (cycleSize==0) {
			System.out.println("YES");
			return;
		}
		int []inCycle = new int[cycleSize+1];
		inCycle = cycle.clone();
		int cnt = cycleSize;
		for (int i = 1; i < cnt; i++) {
			a[inCycle[i+1]][inCycle[i]] = 0;
			findCycle();
			if (cycleSize==0) {
				System.out.println("YES");
				return;
			}
			a[inCycle[i+1]][inCycle[i]] = 1;
		}
		System.out.println("NO");
		pw.close();
	}
	private static void findCycle() {
		Arrays.fill(color, 0);
		cycleSize = 0;
		for (int i = 1; i <= n; i++) {
			if (color[i]==0)
				dfs(i);
		}
	}
	private static void dfs(int v) {
		if (cycleSize > 0)
			return;
		color[v] = 1;
		for (int i = 1; i <= n; i++) {
			if (cycleSize > 0)
				return;
			if (a[v][i]==1) {
				if (color[i]==0) {
					p[i] = v;
					dfs(i);
				}
				else if (color[i]==1) {
					int cur = v;
					while (true) {
						cycle[++cycleSize] = cur;
						if (cur==i)
							break;
						cur = p[cur];
					}
					cycle[++cycleSize] = v;
					return;
				}
			}
		}
		color[v] = 2;
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}