#include <vector>
#include <algorithm>
#include <cassert>
namespace exodus{
	namespace internal{
		class nothing{
		public:
			nothing(){}
			friend nothing operator +(const nothing&,const nothing&){return nothing();}
		};
	}
	template<class info=internal::nothing>
	struct dsu{
	public:
		struct node{
		public:
			node(){anc=-1,siz=1,ifo=info();}
			int anc,siz;
			info ifo;
		};
		dsu():_n(0){}
		explicit dsu(int n){
			_n=n;node.resize(n);
			for(int i=0;i<n;i++)
				node[i].anc=i;
		}
		void build(int n){
			_n=n;
			node.clear();
			node.resize(n);
			for(int i=0;i<n;i++)
				node[i].anc=i;
		}
		int find(int u){
			assert(0<=u&&u<_n);
			return __find(u);
		}
		void merge(int u,int v){
			assert(0<=u&&u<_n);
			assert(0<=v&&v<_n);
			u=__find(u),v=__find(v);
			if(node[u].siz<node[v].siz)std::swap(u,v);
			node[v].anc=u;
			node[u].ifo=node[u].ifo+node[v].ifo;
		}
		bool check(int u,int v){
			assert(0<=u&&u<_n);
			assert(0<=v&&v<_n);
			u=__find(u),v=__find(v);
			return u==v;
		}
	private:
		int _n;
		std::vector<node>node;
		int __find(int u){
			return u==node[u].anc?u:node[u].anc=__find(node[u].anc);
		}
	};
}

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

bitset<7000>bts[7000],used;
vector<int>g[7000];
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	int n,m;
	cin>>n>>m;
	vector<pair<int,int>>edge(m);
	for(auto& [u,v]:edge)
		cin>>u>>v,--u,--v;
	for(auto [u,v]:edge){
		g[u].emplace_back(v);
	}
	auto bfs=[&](int s){
		static queue<int>q;
		q.emplace(s);
		bts[s][s]=true;
		while(!q.empty()){
			int u=q.front();
			q.pop();
			for(auto v:g[u]){
				if(!bts[s][v]){
					bts[s][v]=true;
					q.emplace(v);
				}
			}
		}
	};
	
	for(int i=0;i<n;i++)
		bfs(i);
	
	for(int i=0;i<n;i++){
		bts[i].reset(i);
		for(int j=i+1;j<n;j++){
			if(bts[i].test(j)&&bts[j].test(i)){
				bts[j].reset(i);
			}
		}
	}
	int cnt=n;
	vector<int>pre(n,-1);
	vector<int>nxt(n,-1),mat(n,-1);
	auto spread=[&](int s)-> bool {
		queue<int>q;
		q.emplace(s);
		int pos=-1,target=-1;
		while(!q.empty()){
			int u=q.front();
			q.pop();
			auto good_pro=bts[u]&used;
			for(int v=good_pro._Find_first();v<n;v=good_pro._Find_next(v)){
				used.reset(v);
				if(nxt[v]==-1){
					pos=u;
					target=v;
					goto there;
				}else{
					q.emplace(nxt[v]);
					pre[nxt[v]]=u;
				}
			}
		}
		
		there:;
		if(target==-1)
			return false;
		while(pos!=-1){
			swap(target,mat[pos]);
			nxt[mat[pos]]=pos;
			pos=pre[pos];
		}
		return true;
	};
	for(int i=0;i<n;i++){
		used.set();
		fill(pre.begin(),pre.end(),-1);
		if(spread(i))
			cnt--;
	}
#ifdef EXODUS
	cerr<<cnt<<'\n';
#endif
	// for(int i=0;i<n;i++)
	// 	printf("%d ",nxt[i]);
	// printf("\n");
	exodus::dsu dsu(n);
	for(int u=0;u<n;u++){
		if(nxt[u]!=-1){
			dsu.merge(u,nxt[u]);
		}
	}
	vector<int>ans(n);
	for(int i=0;i<n;i++){
		static int colx=0;
		if(dsu.find(i)==i){
			ans[i]=++colx;
		}
	}
	for(int i=0;i<n;i++){
		ans[i]=ans[dsu.find(i)];
	}
	for(int i=0;i<n;i++)
		cout<<ans[i]<<' ';
	cout<<'\n';
#ifdef EXODUS
	cerr<<clock()<<'\n';
	vector<vector<int>>_g(n);
	vector<vector<int>>reach(n,vector<int>(n));
	for(auto [u,v]:edge){
		_g[u].emplace_back(v);
	}
	auto _bfs=[&](int s){
		static queue<int>q;
		q.emplace(s);
		reach[s][s]=true;
		while(!q.empty()){
			int u=q.front();
			q.pop();
			for(auto v:_g[u]){
				if(!reach[s][v]){
					reach[s][v]=true;
					q.emplace(v);
				}
			}
		}
	};
	for(int i=0;i<n;i++)
		_bfs(i);
	// for(int i=0;i<n;i++,cerr<<'\n')
	// 	for(int j=0;j<n;j++)
	// 		cerr<<reach[i][j]<<' ';
	vector<int>_lis;
	for(int i=1;i<=cnt;i++){
		_lis.clear();
		for(int j=0;j<n;j++)
			if(ans[j]==i)
				_lis.emplace_back(j);
		for(auto u:_lis)
			for(auto v:_lis){
				if(!reach[u][v]&&!reach[v][u]){
					cerr<<"Wrong Answer\n";
					return 1;
				}
			}
	}
	cerr<<"Accept\n";
#endif
	return 0;
}