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.
#include <bits/stdc++.h>
using namespace std;
const int mx = 501;
bool over;
int jala[mx], before[mx];
vector<int> ciclo, ciclo2;
void Deep(vector<int> v[], int x) {
  int i, y;
  if (over) {
    return;
  }
  jala[x] = 1;
  for (i = 0; i < v[x].size(); ++i) {
    if (over) {
      return;
    }
    y = v[x][i];
    if (jala[y] < 2) {
      before[y] = x;
      if (jala[y] < 1) {
        jala[y] = 1;
        Deep(v, y);
      } else {
        over = true;
        y = x;
        do {
          ciclo.push_back(y);
          y = before[y];
        } while (x != y);
      }
    }
  }
  jala[x] = 2;
  return;
}
int main(void) {
  int n, e;
  int i, j;
  int s, f;
  scanf("%d %d", &n, &e);
  vector<int> edges[n];
  over = false;
  while (e--) {
    scanf("%d %d", &s, &f);
    edges[s - 1].push_back(f - 1);
  }
  memset(jala, 0, sizeof(jala));
  for (i = 0; i < n; ++i) {
    if (!over) {
      Deep(edges, i);
    } else {
      break;
    }
  }
  if (!over) {
    printf("YES\n");
  } else {
    e = ciclo.size();
    ciclo2 = ciclo;
    for (i = 0; i < e; i++) {
      over = false;
      s = ciclo[i];
      f = ciclo[(i + e - 1) % e];
      for (j = 0; j < edges[s].size(); ++j) {
        if (edges[s][j] == f) {
          edges[s].erase(edges[s].begin() + j);
          break;
        }
      }
      memset(jala, 0, sizeof(jala));
      for (j = 0; j < n; j++) {
        if (!over) {
          Deep(edges, j);
        } else {
          break;
        }
      }
      if (!over) {
        printf("YES\n");
        break;
      }
      edges[s].push_back(f);
      ciclo = ciclo2;
    }
    if (over) {
      printf("NO\n");
    }
  }
  return 0;
}
