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.List;
import java.util.Scanner;

//http://codeforces.com/problemset/problem/915/D
//http://codeforces.com/contest/915/submission/34154383
public class AlmostAcyclicGraph {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		List<List<Integer>> adj = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			adj.add(new ArrayList<>());
		}
		for (int i = 0; i < m; i++) {
			int s = sc.nextInt() - 1;
			int e = sc.nextInt() - 1;
			adj.get(s).add(e);
		}
		sc.close();
		State[] nodes = new State[n];
		for (int i = 0; i < nodes.length; i++) {
			nodes[i] = State.NOT_VISITED;
		}
		List<int[]> edgesInCycle = new ArrayList<int[]>();
		for (int i = 0; i < n; i++) {
			if (nodes[i] == State.NOT_VISITED && findCycle(adj, i, nodes, edgesInCycle)) {
				break;
			}
		}
		// no cycles
		if (edgesInCycle.size() == 0) {
			System.out.println("YES");
		} else {
			for (int[] edge : edgesInCycle) {
				if (traverse(adj, n, edge)) {
					System.out.println("YES");
					return;
				}
			}
			System.out.println("NO");
		}
	}

	public static enum State {
		NOT_VISITED, VISITED, NO_CYCLE;
	}

	/**
	 * Looks for a cycle in the adj matrix that contains start. If it finds one, it
	 * adds every edge in the cycle to edgesInCycles. Returns true if a cycle is
	 * found, and false otherwise.
	 */
	private static boolean findCycle(List<List<Integer>> adj, int start, State[] nodes, List<int[]> edgesInCycles) {
		nodes[start] = State.VISITED;
		for (int end : adj.get(start)) {
			if (nodes[end] == State.VISITED) {
				edgesInCycles.add(new int[] { start, end });
				return true;
			} else if (nodes[end] == State.NOT_VISITED && findCycle(adj, end, nodes, edgesInCycles)) {
				edgesInCycles.add(new int[] { start, end });
				return true;
			}
		}
		nodes[start] = State.NO_CYCLE;
		return false;
	}

	/**
	 * Looks for a cycle in the adj matrix that contains start. Does not use the
	 * given edge. Returns true if a cycle is found, and false otherwise.
	 */
	private static boolean checkCycle(List<List<Integer>> adj, int start, State[] nodes, int[] edge) {
		nodes[start] = State.VISITED;
		for (int end : adj.get(start)) {
			// ignore given cycle.
			if (start != edge[0] || end != edge[1]) {
				if (nodes[end] == State.VISITED) {
					return true;
				} else if (nodes[end] == State.NOT_VISITED && checkCycle(adj, end, nodes, edge)) {
					return true;
				}
			}
		}
		nodes[start] = State.NO_CYCLE;
		return false;
	}

	/**
	 * @return true if removing the given edge will cause the graph to have no
	 *         cycles.
	 */
	private static boolean traverse(List<List<Integer>> adj, int n, int[] edge) {
		State[] nodes = new State[n];
		for (int i = 0; i < nodes.length; i++) {
			nodes[i] = State.NOT_VISITED;
		}
		for (int i = 0; i < n; i++) {
			if (nodes[i] == State.NOT_VISITED && checkCycle(adj, i, nodes, edge)) {
				return false;
			}
		}
		return true;
	}
}
