There are n cities in the kingdom X, numbered from 1 through n. People travel between cities by some one-way roads. As a passenger, JATC finds it weird that from any city u, he can't start a trip in it and then return back to it using the roads of the kingdom. That is, the kingdom can be viewed as an acyclic graph.

Being annoyed by the traveling system, JATC decides to meet the king and ask him to do something. In response, the king says that he will upgrade some cities to make it easier to travel. Because of the budget, the king will only upgrade those cities that are important or semi-important. A city u is called important if for every city v ≠ u, there is either a path from u to v or a path from v to u. A city u is called semi-important if it is not important and we can destroy exactly one city v ≠ u so that u becomes important.

The king will start to act as soon as he finds out all those cities. Please help him to speed up the process.

Input

The first line of the input contains two integers n and m (2 ≤ n ≤ 300 000, 1 ≤ m ≤ 300 000) — the number of cities and the number of one-way roads.

Next m lines describe the road system of the kingdom. Each of them contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), denoting one-way road from u_i to v_i.

It is guaranteed, that the kingdoms' roads make an acyclic graph, which doesn't contain multiple edges and self-loops.

Output

Print a single integer — the number of cities that the king has to upgrade.

Examples

Input

7 7
1 2
2 3
3 4
4 7
2 5
5 4
6 4


Output

4

Input

6 7
1 2
2 3
3 4
1 5
5 3
2 6
6 4


Output

4

Note

In the first example: 

<image>

  * Starting at the city 1 we can reach all the other cities, except for the city 6. Also, from the city 6 we cannot reach the city 1. Therefore, if we destroy the city 6 then the city 1 will become important. So 1 is a semi-important city. 
  * For city 2, the set of cities that cannot reach 2 and cannot be reached by 2 is \{6\}. Therefore, destroying city 6 will make the city 2 important. So city 2 is also semi-important. 
  * For city 3, the set is \{5, 6\}. As you can see, destroying either city 5 or 6 will not make the city 3 important. Therefore, it is neither important nor semi-important. 
  * For city 4, the set is empty. So 4 is an important city. 
  * The set for city 5 is \{3, 6\} and the set for city 6 is \{3, 5\}. Similarly to city 3, both of them are not important nor semi-important. 
  * The city 7 is important since we can reach it from all other cities. 

So we have two important cities (4 and 7) and two semi-important cities (1 and 2).

In the second example, the important cities are 1 and 4. The semi-important cities are 2 and 3.
#include <bits/stdc++.h>
const int max_N = 302401;
int n, m, ans, num[max_N], deg[max_N];
std::vector<std::vector<int> > G[2];
std::queue<int> Q;
int read() {
  char c = getchar();
  int ans = 0;
  bool flag = true;
  while (!isdigit(c)) flag &= (c != '-'), c = getchar();
  while (isdigit(c)) ans = ans * 10 + c - '0', c = getchar();
  return flag ? ans : -ans;
}
void Write(int x) {
  if (x < 0) putchar('-'), x = -x;
  if (x < 10)
    putchar(x + '0');
  else
    Write(x / 10), putchar(x % 10 + '0');
}
int min(int x, int y) { return x < y ? x : y; }
int max(int x, int y) { return x > y ? x : y; }
void _min(int &x, int y) {
  if (x > y) x = y;
}
void _max(int &x, int y) {
  if (x < y) x = y;
}
void solve(std::vector<std::vector<int> > G) {
  std::fill(deg + 1, deg + n + 1, 0);
  for (int i = 1; i <= n; i++)
    for (auto j : G[i]) ++deg[j];
  for (int i = 1; i <= n; i++)
    if (!deg[i]) Q.push(i);
  for (int i = 1; i <= n; i++) {
    int cur = Q.front();
    Q.pop();
    if (Q.empty()) num[cur] += n - i;
    if (Q.size() == 1) {
      bool flag = true;
      for (auto j : G[Q.front()]) flag &= (deg[j] > 1);
      if (flag) num[cur] += n - i - 1;
    }
    for (auto j : G[cur])
      if (!--deg[j]) Q.push(j);
  }
}
int main() {
  n = read(), m = read();
  G[0].resize(n + 1), G[1].resize(n + 1);
  for (int i = 1, u, v; i <= m; i++)
    u = read(), v = read(), G[0][u].push_back(v), G[1][v].push_back(u);
  solve(G[0]), solve(G[1]);
  for (int i = 1; i <= n; i++) ans += (num[i] >= n - 2);
  return Write(ans), 0;
}
