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>
void alert(const T& t) {
  cout << t << endl;
  exit(0);
}
struct Edge {
  Edge() = default;
  Edge(int to) : to(to), active(true) {}
  int to;
  bool active = true;
};
struct Node {
  int p = -1;
  char used = 'w';
  vector<Edge> e;
};
int n, m;
vector<Node> g;
vector<int> cycle_path;
bool was_cycle = false;
bool can = false;
void Clear() {
  for (auto& it : g) it.used = 'w';
}
bool DFS(int f, int p, int mode = 1) {
  g[f].used = 'g';
  for (auto& it : g[f].e) {
    if (!it.active) continue;
    if (g[it.to].used == 'g') {
      if (mode) {
        int cycle_start = it.to;
        int cycle_end = f;
        for (int i = cycle_end; i != cycle_start; i = g[i].p) {
          cycle_path.push_back(i);
        }
        cycle_path.push_back(cycle_start);
        reverse((cycle_path).begin(), (cycle_path).end());
      }
      g[f].used = 'b';
      return true;
    } else if (g[it.to].used == 'w') {
      g[it.to].p = f;
      if (DFS(it.to, f)) {
        g[f].used = 'b';
        return true;
      }
    }
  }
  g[f].used = 'b';
  return false;
}
void Read() {
  cin >> n >> m;
  g.assign(n, Node());
  for (int i = 0; i < m; ++i) {
    int a, b;
    cin >> a >> b;
    --a;
    --b;
    g[a].e.push_back(Edge(b));
  }
}
void Solve() {
  for (int i = 0; i < n; ++i) {
    if (g[i].used == 'w') {
      if (DFS(i, -1)) {
        was_cycle = true;
        break;
      }
    }
  }
  if (!was_cycle) return;
  vector<vector<Edge>::iterator> edge_cycle;
  for (int i = 0; i < cycle_path.size(); ++i) {
    int v = cycle_path[i];
    int u = cycle_path[(i == cycle_path.size() - 1 ? 0 : i + 1)];
    for (vector<Edge>::iterator i = g[v].e.begin(); i != g[v].e.end(); i++) {
      if (i->to == u) {
        edge_cycle.push_back(i);
        break;
      }
    }
  }
  for (int i = 0; i < edge_cycle.size(); ++i) {
    if (i > 0) edge_cycle[i - 1]->active = true;
    edge_cycle[i]->active = false;
    bool findAnotherOne = false;
    Clear();
    for (int i = 0; i < n; ++i) {
      if (g[i].used == 'w') {
        findAnotherOne |= DFS(i, -1, 0);
      }
    }
    if (!findAnotherOne) can = true;
  }
}
void Print() {
  if (!was_cycle || can)
    cout << "YES";
  else
    cout << "NO";
  cout << endl;
}
int main() {
  {}
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  Read();
  Solve();
  Print();
  return 0;
}
