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.*;

public class AlmostAcyclicGraph {
    private final int n, m;
    private final int[][] edges;
    private final int[] inDeg;
    private final List<List<Integer>> adj;
    
    public AlmostAcyclicGraph(int n, int m, int[][] edges) {
        this.n = n;
        this.m = m;
        this.edges = edges;
        inDeg = new int[n];
        adj = new ArrayList<>(n);
        preprocess();
    }
    
    private void preprocess() {
        for(int i = 0; i < n; i++) {
            adj.add(new ArrayList<>());
        }
        for(int[] edge: edges) {
            int u = edge[0] - 1;
            int v = edge[1] - 1;
            adj.get(u).add(v);
            inDeg[v]++;
        }
    }
    
    private boolean feasible(int x) {
        // make a copy
        int[] deg = inDeg.clone();
        deg[x]--;
        Queue<Integer> q = new LinkedList<>();
        // all those with 0 inDegree should be enqueued
        boolean[] visited = new boolean[n];
        int count = 0;
        for(int i = 0; i < n; i++) {
            if(deg[i] == 0) {
                q.add(i);
            }
        }
        while(!q.isEmpty()) {
            int u = q.poll();
            visited[u] = true;
            count++;
            for(int v: adj.get(u)) {
                deg[v]--;
                if(!visited[v] && deg[v] == 0) {
                    q.add(v);
                }
            }
        }
        return count == n;
    }
    
    public boolean possible() {
        for(int x = 0; x < n; x++) {
            if(inDeg[x] > 0) {
                if(feasible(x)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); 
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[][] edges = new int[m][2];
        for(int i = 0; i < m; i++) {
            edges[i][0] = sc.nextInt();
            edges[i][1] = sc.nextInt();
        }
        AlmostAcyclicGraph instance = new AlmostAcyclicGraph(n, m, edges);
        System.out.println(instance.possible() ? "YES" : "NO");
    }
}
