#include <bits/stdc++.h>
using namespace std;

#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 long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

typedef bitset<7000> BS;

vi val, comp, z, cont;
int Time, ncomps;
template<class G, class F> int dfss(int j, G& g, F& f) {
	int low = val[j] = ++Time, x; z.push_back(j);
	for (auto e : g[j]) if (comp[e] < 0)
		low = min(low, val[e] ?: dfss(e,g,f));

	if (low == val[j]) {
		do {
			x = z.back(); z.pop_back();
			comp[x] = ncomps;
			cont.push_back(x);
		} while (x != j);
		f(cont); cont.clear();
		ncomps++;
	}
	return val[j] = low;
}
template<class G, class F> void sccd(G& g, F f) {
	int n = sz(g);
	val.assign(n, 0); comp.assign(n, -1);
	Time = ncomps = 0;
	rep(i,0,n) if (comp[i] < 0) dfss(i, g, f);
}

bool dfsh(int a, int L, vector<vi>& g, vi& btoa, vi& A, vi& B) {
	if (A[a] != L) return 0;
	A[a] = -1;
	for (int b : g[a]) if (B[b] == L + 1) {
		B[b] = 0;
		if (btoa[b] == -1 || dfsh(btoa[b], L + 1, g, btoa, A, B))
			return btoa[b] = a, 1;
	}
	return 0;
}

int hopcroftKarp(vector<vi>& 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 : g[a]) {
				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 += dfsh(a, 0, g, btoa, A, B);
	}
}

void dfs1(int now, int st, BS &vis, vector<vector<int>> &g, vector<int> &outdeg, vector<vector<int>> &gg) {
	vis[now] = 1;
	if (outdeg[now] == 0) {
		if (now != st) {
			gg[st].push_back(now);
		}
		return;
	}

	for (int u: g[now]) {
		if (!vis[u]) {
			dfs1(u, st, vis, g, outdeg, gg);
		}
	}
}

void dfs2(int now, BS &vis, vector<vector<int>> &g) {
	vis[now] = 1;
	for (int u: g[now]) {
		if (!vis[u]) {
			dfs2(u, vis, g);
		}
	}
}

signed main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n, m; cin >> n >> m;
	vector<vector<int>> g1(n);
	vector<pair<int, int>> e;
	for (int i = 0; i < m; i++) {
		int x, y; cin >> x >> y; x--, y--;
		g1[x].push_back(y);
		e.emplace_back(x, y);
	}	

	int petr = 0;
	vector<int> scc(n);
	sccd(g1, [&](vi &v) {
		for (int i: v) {
			scc[i] = petr;
		}
		petr++;
	});

	vector<vector<int>> g2(petr);
	vector<int> indeg(petr), outdeg(petr);
	set<pair<int, int>> e2;
	for (auto [x, y]: e) {
		int u = scc[x], v = scc[y];
		if (u != v) {
			if (e2.count({u, v})) continue;
			g2[u].push_back(v);
			e2.insert({u, v});
			indeg[v]++; outdeg[u]++;
		}
	}

	vector<vector<int>> g3(petr);
	for (int i = 0; i < petr; i++) {
		if (indeg[i] == 0) {
			BS vis;
			dfs1(i, i, vis, g2, outdeg, g3);
		}
	}

	vector<BS> reachable(petr);
	for (int i = 0; i < petr; i++) {
		dfs2(i, reachable[i], g2);
	}

	vi btoa(petr, -1); hopcroftKarp(g3, btoa);
	vector<int> colscc(petr); int petrc = 1;

	vector<pair<int, int>> matches;
	vector<int> solo;

	for (int i = 0; i < petr; i++) {
		if (outdeg[i] == 0) {
			if (btoa[i] != -1) {
				colscc[i] = petrc;
				colscc[btoa[i]] = petrc;
				matches.emplace_back(btoa[i], i);
			} else {
				colscc[i] = petrc;
				solo.push_back(i);
			}
			petrc++;
		}
	}
	for (int i = 0; i < petr; i++) {
		if (indeg[i] == 0) {
			if (colscc[i] == 0) {
				colscc[i] = petrc;
				solo.push_back(i);
				petrc++;
			}
		}
	}

	for (int i = 0; i < petr; i++) {
		if (colscc[i] == 0) {
			for (auto [a, b]: matches) {
				if (reachable[a][i] && reachable[i][b]) {
					colscc[i] = colscc[a];
					break;
				}
			}
		}
	}
	for (int i = 0; i < petr; i++) {
		if (colscc[i] == 0) {
			for (int u: solo) {
				if (reachable[u][i] || reachable[i][u]) {
					colscc[i] = colscc[u];
					break;
				}
			}
		}
	}

	for (int i = 0; i < n; i++) {
		cout << colscc[scc[i]] << ' ';
	}
	cout << '\n';
	
	return 0;
}