#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = {{-1, 0}, {0, 1}, {1, 0},  {0, -1},
                        {-1, 1}, {1, 1}, {1, -1}, {-1, -1}};
template <class T>
inline T abs1(T a) {
  return a < 0 ? -a : a;
}
template <typename t, typename t1>
t min1(t a, t1 b) {
  return a < b ? a : b;
}
template <typename t, typename... arg>
t min1(t a, arg... arr) {
  return min1(a, min1(arr...));
}
template <typename t, typename t1>
t max1(t a, t1 b) {
  return a > b ? a : b;
}
template <typename t, typename... arg>
t max1(t a, arg... arr) {
  return max1(a, max1(arr...));
}
inline int jud(double a, double b) {
  if (abs(a) < eps && abs(b) < eps)
    return 0;
  else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps)
    return 0;
  if (a < b) return -1;
  return 1;
}
template <typename t>
inline int jud(t a, t b) {
  if (a < b) return -1;
  if (a == b) return 0;
  return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
  if (na == 0) return 0;
  int be = 0, en = na - 1;
  if (*a <= *(a + na - 1)) {
    if (f_lb == 0)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != 1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != -1)
          en = mid;
        else
          be = mid + 1;
      }
    if (f_small && jud(*(a + be), val) == 1) be--;
    if (!f_small && jud(*(a + be), val) == -1) be++;
  } else {
    if (f_lb)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(*(a + mid), val) != -1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(*(a + mid), val) != 1)
          en = mid;
        else
          be = mid + 1;
      }
    if (!f_small && jud(*(a + be), val) == -1) be--;
    if (f_small && jud(*(a + be), val) == 1) be++;
  }
  return be;
}
template <class T>
inline T lowb(T num) {
  return num & (-num);
}
long long pow(long long n, long long m, long long mod = 0) {
  if (m < 0) return 0;
  long long ans = 1;
  long long k = n;
  while (m) {
    if (m & 1) {
      ans *= k;
      if (mod) ans %= mod;
    }
    k *= k;
    if (mod) k %= mod;
    m >>= 1;
  }
  return ans;
}
template <class t1, class t2>
inline void add(t1 &a, t2 b, int mod = -1) {
  if (mod == -1) mod = 1000000007;
  a += b;
  while (a >= mod) a -= mod;
  while (a < 0) a += mod;
}
template <class t>
void output1(t arr) {
  for (int i = 0; i < (int)arr.size(); i++) cerr << arr[i] << ' ';
  cerr << endl;
}
template <class t>
void output2(t arr) {
  for (int i = 0; i < (int)arr.size(); i++) output1(arr[i]);
}
const int maxm = 5010;
const int maxn = 5010;
struct edge {
  int to, nxt;
} e[maxm * 2];
int head[maxn], le;
int n, m;
int pnt[maxn], deep[maxn], st[maxn], lst;
int id[maxn], scnt, deg[maxn], allcnt;
void tarjan(int no) {
  pnt[no] = deep[no] = allcnt++;
  st[lst++] = no;
  for (int i = head[no]; i != -1; i = e[i].nxt) {
    if (pnt[e[i].to] == -1) {
      tarjan(e[i].to);
    }
    pnt[no] = min(pnt[no], pnt[e[i].to]);
  }
  if (pnt[no] == deep[no]) {
    while (1) {
      int rno = st[lst - 1];
      id[rno] = scnt;
      pnt[rno] = n + 10;
      lst--;
      if (st[lst] == no) break;
    }
    scnt++;
  }
}
int findmincir(int scc) {
  int q[maxn], lq;
  int ans = n + 2;
  for (int i = 0; i < n; i++)
    if (id[i] == scc) {
      if (head[i] == -1) return -1;
      lq = 0;
      q[lq++] = i;
      memset(deep, 0x3f, sizeof(deep));
      deep[i] = 0;
      int rans = n + 2;
      for (int j = 0; j < lq && rans > n; j++) {
        int no = q[j];
        for (int k = head[no]; k != -1; k = e[k].nxt) {
          if (e[k].to == i) {
            rans = min(rans, deep[no] + 1);
            break;
          }
          if (deep[e[k].to] > deep[no] + 1) {
            deep[e[k].to] = deep[no] + 1;
            q[lq++] = e[k].to;
          }
        }
      }
      ans = min(ans, rans);
    }
  return ans;
}
int main() {
  ios_base::sync_with_stdio(0);
  memset(head, -1, sizeof(head));
  memset(pnt, -1, sizeof(pnt));
  scanf("%d%d", &n, &m);
  bool debug = 0;
  for (int i = 0; i < m; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    if (i == 0 && a == 1 && b == 2) debug = 1;
    a--;
    b--;
    e[le].to = b;
    e[le].nxt = head[a];
    head[a] = le++;
  }
  for (int i = 0; i < n; i++)
    if (pnt[i] == -1) {
      tarjan(i);
    }
  for (int i = 0; i < n; i++)
    for (int j = head[i]; j != -1; j = e[j].nxt)
      if (id[i] != id[e[j].to]) deg[id[i]]++;
  int ans = n;
  for (int i = 0; i < scnt; i++)
    if (deg[i] == 0) {
      int k = findmincir(i);
      if (k != -1) ans += k * 998 + 1;
    }
  cout << ans << endl;
  return 0;
}
