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.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;


public class q5 {
	static ArrayList<Integer> gph[];
	static int tempdeg[],deg[];
	static int n;
	
	static boolean check() {
		int ans=0;
		Queue<Integer> q=new LinkedList<Integer>();
		for(int i=1;i<=n;i++) {
			if(tempdeg[i]==0) {
				q.add(i);
			}
		}
		while(q.size()!=0) {
			ans++;
			int a=q.poll();
			for(int b:gph[a]) {
				tempdeg[b]--;
				if(tempdeg[b]==0)q.add(b);
			}
		}
		return ans==n;
	}
	
	public static void main(String[] args) throws IOException {
		
		Reader.init(System.in);
		PrintWriter out=new PrintWriter(System.out);
		n=Reader.nextInt();
		gph=new ArrayList[n+1];
		tempdeg=new int[n+1];deg=new int[n+1];
		for(int i=1;i<=n;i++)gph[i]=new ArrayList<Integer>();
		int m=Reader.nextInt();
		for(int i=0;i<m;i++) {
			int a=Reader.nextInt(),b=Reader.nextInt();
			deg[a]++;
			tempdeg[a]++;
			gph[b].add(a);
		}
		String ans="NO";
		if(check()) {
			ans="YES";
		}
		else {
			for(int i=1;i<=n;i++) {
				if(deg[i]>0) {
					for(int j=1;j<=n;j++) {
						tempdeg[j]=deg[j];
						if(j==i) tempdeg[j]--;
					}
					if(check()) {
						ans="YES";break;
					}
				}
			}
		}
		out.print(ans);
		out.flush();
		
	}
}





class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;
    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }
    /** get next word */
    static String nextLine() throws IOException{
    	return reader.readLine();
    }
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }
    static int nextInt() throws IOException {
        return Integer.parseInt( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
}