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.
// /package CF;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A {
	static ArrayList<Integer> [] adj;
	static int [] vis, par;
	static int s, t;
	static ArrayList<Integer> cyc; 
	static final int VISITED = 2, EXPLORED = 1, UNVISITED = 0;
	static boolean f, c;
	static void dfs(int u){
		vis[u] = EXPLORED;
		for(int v:adj[u]){
			if(u == s && v == t) continue;
			if(vis[v] == UNVISITED){
				par[v] = u;
				dfs(v);
			}
			else if(vis[v] == EXPLORED)
			{
				f = false;
				if(!c && cyc.size() == 0){
					int cur = u;
					cyc.add(cur);
					while(true){
						cur = par[cur];
						cyc.add(cur);
						if(cur == v) break;
					}
				}
			}
		}
		vis[u] = VISITED;
	}
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt(), m = sc.nextInt();
		adj = new ArrayList[n];
		for (int i = 0; i < adj.length; i++) {
			adj[i] = new ArrayList<>();
		}
		s = t = -1;
		vis = new int[n];
		par = new int[n];
		for (int i = 0; i < m; i++) {
			int u = sc.nextInt(), v = sc.nextInt();
			u--;
			v--;
			adj[u].add(v);
		}
		cyc = new ArrayList<>();
		for (int i = 0; i < n; i++) {
			if(vis[i] == UNVISITED)
				dfs(i);
		}
		if(cyc.size() == 0)
			out.println("YES");
		else{
			c = true;
			boolean fnd = false;
			int sz = cyc.size();
			for (int i = sz-1; i >= 0; i--) {
				f = true;
				s = cyc.get(i); t = cyc.get((i-1+sz)%sz);
				Arrays.fill(vis, UNVISITED);
				for (int j = 0; j < n; j++)
					if(vis[j] == UNVISITED)
						dfs(j);
				if(f){
					fnd = true;
					break;
				}
			}
			out.println(fnd?"YES":"NO");
		}
		out.flush();
		out.close();
	}
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader fileReader) {
			br = new BufferedReader(fileReader);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public boolean ready() throws IOException {
			return br.ready();
		}
	}
}