#pragma GCC optimize("O2")
#include <algorithm>
#include <array>
#include <bit>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <compare>
#include <complex>
#include <concepts>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numbers>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ranges>
#include <set>
#include <span>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <variant>

#define int ll
#define INT128_MAX (__int128)(((unsigned __int128) 1 << ((sizeof(__int128) * __CHAR_BIT__) - 1)) - 1)
#define INT128_MIN (-INT128_MAX - 1)

namespace R = std::ranges;
namespace V = std::views;

using namespace std;

using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using tiii = tuple<int, int, int>;
using ldb = long double;
//#define double ldb

template<class T>
ostream& operator<<(ostream& os, const pair<T, T> pr) {
  return os << pr.first << ' ' << pr.second;
}
template<class T, size_t N>
ostream& operator<<(ostream& os, const array<T, N> &arr) {
  for(const T &X : arr)
    os << X << ' ';
  return os;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T> &vec) {
  for(const T &X : vec)
    os << X << ' ';
  return os;
}

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef vector<int> vi;

/**
 * Author: Chen Xing
 * Date: 2009-10-13
 * License: CC0
 * Source: N/A
 * Description: Fast bipartite matching algorithm. Graph $g$ should be a list
 * of neighbors of the left partition, and $btoa$ should be a vector full of
 * -1's of the same size as the right partition. Returns the size of
 * the matching. $btoa[i]$ will be the match for vertex $i$ on the right side,
 * or $-1$ if it's not matched.
 * Usage: vi btoa(m, -1); hopcroftKarp(g, btoa);
 * Time: O(\sqrt{V}E)
 * Status: stress-tested by MinimumVertexCover, and tested on oldkattis.adkbipmatch and SPOJ:MATCHING
 */

using graph = array<bitset<7000>, 7000>;

bool dfs(int a, int L, graph& g, vi& btoa, vi& A, vi& B) {
	if (A[a] != L) return 0;
	A[a] = -1;
	for(int b = 0; b < sz(g); b++) if (g[a][b] and B[b] == L + 1) {
		B[b] = 0;
		if (btoa[b] == -1 || dfs(btoa[b], L + 1, g, btoa, A, B))
			return btoa[b] = a, 1;
	}
	return 0;
}

int hopcroftKarp(graph& g, vi& btoa) {
	int res = 0;
	vi A(g.size()), B(btoa.size()), cur, next;
	for (;;) {
		fill(all(A), 0);
		fill(all(B), 0);
		/// Find the starting nodes for BFS (i.e. layer 0).
		cur.clear();
		for (int a : btoa) if(a != -1) A[a] = -1;
		rep(a,0,sz(g)) if(A[a] == 0) cur.push_back(a);
		/// Find all layers using bfs.
		for (int lay = 1;; lay++) {
			bool islast = 0;
			next.clear();
			for (int a : cur) for(int b = 0; b < sz(g); b++) {
        if (!g[a][b]) continue;
				if (btoa[b] == -1) {
					B[b] = lay;
					islast = 1;
				}
				else if (btoa[b] != a && !B[b]) {
					B[b] = lay;
					next.push_back(btoa[b]);
				}
			}
			if (islast) break;
			if (next.empty()) return res;
			for (int a : next) A[a] = lay;
			cur.swap(next);
		}
		/// Use DFS to scan for augmenting paths.
		rep(a,0,sz(g))
			res += dfs(a, 0, g, btoa, A, B);
	}
}

/**
 * template name: SCC
 * author: Misuki
 * last update: 2023/01/07
 * verify: Library Checker - Strongly Connected Components
 */

struct SCC {
  int ssz;
  vector<int> group_id;
  vector<vector<int>> group;
  vector<vector<int>> G;

  SCC(vector<vector<int>> &g) : group_id(g.size()), ssz(0) {
    vector<vector<int>> gr(g.size());
    for(int i = 0; i < g.size(); i++)
      for(int X : g[i])
        gr[X].emplace_back(i);

    int t = 0;
    vector<bool> vis(g.size(), false);
    vector<int> tout(g.size());
    auto dfs = [&](int V, auto self) -> void {
      vis[V] = true;
      for(int X : gr[V])
        if (!vis[X])
          self(X, self);
      tout[t++] = V;
    };

    for(int i = 0; i < g.size(); i++)
      if (!vis[i])
        dfs(i, dfs);

    auto dfs2 = [&](int V, auto self) -> void {
      vis[V] = true;
      for(int X : g[V])
        if (!vis[X])
          self(X, self);
      group_id[V] = ssz;
    };
    for(int i = 0; i < g.size(); i++)
      vis[i] = false;
    for(int i = (int)g.size() - 1; i >= 0; i--) {
      if (!vis[tout[i]]) {
        dfs2(tout[i], dfs2);
        ssz += 1;
      }
    }

    for(int i = 0; i < g.size(); i++)
      group_id[i] = ssz - 1 - group_id[i];

    group.resize(ssz);
    for(int i = 0; i < g.size(); i++)
      group[group_id[i]].emplace_back(i);

    G.resize(ssz);
    for(int i = 0; i < g.size(); i++)
      for(int X : g[i])
        if (group_id[i] != group_id[X])
          G[group_id[i]].emplace_back(group_id[X]);
  }
};

signed main() {
  ios::sync_with_stdio(false), cin.tie(NULL);

  int n, m; cin >> n >> m;
  vector<vector<int>> g(n);
  for(int i = 0; i < m; i++) {
    int u, v; cin >> u >> v;
    g[u - 1].emplace_back(v - 1);
  }

  SCC scc(g);
  array<bitset<7000>, 7000> g2 = {};
  for(int v = scc.ssz - 1; v >= 0; v--) {
    for(int x : scc.G[v]) {
      g2[v] |= g2[x];
      g2[v][x] = true;
    }
  }

  vector<int> btoa(7000, -1);
  hopcroftKarp(g2, btoa);

  vector<int> ans(n);
  for(int s = scc.ssz - 1, c = 1; s >= 0; s--) {
    if (ans[scc.group[s][0]]) continue;
    int v = s;
    do {
      for(int x : scc.group[v])
        ans[x] = c;
      v = btoa[v];
    } while(v != -1);
    c++;
  }

  cout << ans << '\n';

  return 0;
}