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;
template <typename T>
inline T abs(T t) {
  return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
const int MAXN = 513;
int n, m, k;
int s[MAXN];
int proi[MAXN][MAXN];
vector<int> adj[MAXN];
vector<pair<int, int> > ar;
int mrk[MAXN], prv[MAXN], deg[MAXN];
void go() {
  queue<int> q;
  for (int a = 1; a <= n; a++) {
    if (deg[a] == 0) q.push(a);
  }
  int cnt = 0;
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    cnt++;
    for (int nxt : adj[u]) {
      if (proi[u][nxt]) continue;
      deg[nxt]--;
      if (deg[nxt] == 0) q.push(nxt);
    }
  }
  if (cnt == n) {
    puts("YES");
    exit(0);
  }
}
vector<int> cic;
void dfs(int u, int ini) {
  mrk[u] = ini;
  for (int nxt : adj[u]) {
    if (mrk[nxt] != ini) {
      prv[nxt] = u;
      dfs(nxt, ini);
      if (!cic.empty()) return;
    }
    if (nxt == ini) {
      int v = u;
      cic.push_back(u);
      while (v != ini) {
        v = prv[v];
        cic.push_back(v);
      }
      return;
    }
  }
}
int ideg[MAXN];
int main() {
  scanf("%d%d", &n, &m);
  for (int a = 0; a < m; a++) {
    int i, j;
    scanf("%d%d", &i, &j);
    ar.push_back(pair<int, int>(i, j));
    adj[i].push_back(j);
    ideg[j]++;
  }
  for (int a = 1; a <= n && cic.empty(); a++) {
    dfs(a, a);
  }
  if (cic.empty()) {
    puts("YES");
    return 0;
  }
  int tc = cic.size();
  for (int i = tc - 1; i >= 0; i--) {
    int u = cic[i];
    int v = cic[(i + tc - 1) % tc];
    ;
    for (int a = 1; a <= n; a++) {
      deg[a] = ideg[a];
      ;
    }
    deg[v]--;
    ;
    proi[u][v] = 1;
    go();
    proi[u][v] = 0;
  }
  puts("NO");
}
