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>
const int N = 500;
bool have_cycle;
int cycle_head = -1, cycle_start, mark[N], prev[N];
std::vector<int> cycle_vertexes;
std::vector<int> g[N];
bool dfs1(int u);
void dfs2(int u);
int main() {
  std::ios::sync_with_stdio(0);
  std::cin.tie(0);
  std::cout.tie(0);
  int n, m;
  std::cin >> n >> m;
  for (int i = 0; i < m; i++) {
    int u, v;
    std::cin >> u >> v;
    u--;
    v--;
    g[u].emplace_back(v);
  }
  std::fill(prev, prev + n, -1);
  for (int u = 0; u < n; u++) {
    if (dfs1(u)) {
      break;
    }
  }
  if (cycle_head == -1) {
    std::cout << "YES" << std::endl;
  } else {
    for (int u = cycle_head; u != cycle_start; u = prev[u]) {
      cycle_vertexes.emplace_back(u);
    }
    cycle_vertexes.emplace_back(cycle_start);
    std::stack<std::pair<int, int>> cycle_edges;
    for (int u = cycle_vertexes.size() - 1; u; u--) {
      cycle_edges.push({cycle_vertexes[u], cycle_vertexes[u - 1]});
    }
    cycle_edges.push({cycle_vertexes.front(), cycle_vertexes.back()});
    for (; !cycle_edges.empty(); cycle_edges.pop()) {
      std::pair<int, int> edge = cycle_edges.top();
      auto pos = find(g[edge.first].begin(), g[edge.first].end(), edge.second);
      *pos = -1;
      have_cycle = false;
      std::fill(mark, mark + n, 0);
      for (int u = 0; u < n; u++) {
        if (!mark[u]) {
          dfs2(u);
        }
      }
      *pos = edge.second;
      if (!have_cycle) {
        std::cout << "YES" << std::endl;
        return 0;
      }
    }
    std::cout << "NO" << std::endl;
  }
  return 0;
}
bool dfs1(int u) {
  mark[u] = 1;
  for (auto v : g[u]) {
    if (!mark[v]) {
      prev[v] = u;
      if (dfs1(v)) {
        return true;
      }
    } else if (mark[v] == 1) {
      cycle_head = u;
      cycle_start = v;
      return true;
    }
  }
  mark[u] = 2;
  return false;
}
void dfs2(int u) {
  mark[u] = 1;
  for (auto v : g[u]) {
    if (v != -1) {
      if (!mark[v]) {
        dfs2(v);
      } else if (mark[v] == 1) {
        have_cycle = true;
      }
    }
  }
  mark[u] = 2;
}
