#include<iostream>
#include<cmath>
#include<cstring>
#include<cassert>
#include<string>
#include<queue>
#include<deque>
#include<stack>
#include<algorithm>
#include<unordered_map>
#include<map>
#include<vector>
#include<set>
#include<unordered_set>
#include<bitset>
#include<climits>
#include<numeric>
#include<functional>
#include<iomanip>
#include<random>
#ifdef YJL
#include<debug.h>
#else
#define debug(args...)0
#define debug_n(a,n)0
#endif
using namespace std;
typedef long long ll;

const int N = 2e5 + 10;
namespace Graph {
	struct ty {
		int t,l,next;
	} edge[int(2e6)+10];
	int en,head[N];
	void initGraph(int n) {
		fill_n(head+1,n,-1),en=0;
	}
	void addEdge(int x,int y,int z=0) {
		edge[en]={y,z,head[x]};
		head[x]=en++;
	}
}
int n,m;
int dfn[N], low[N], dn;
int sta[N], insta[N], top;
int color[N], cn;
void tarjan(int u) {
	using namespace Graph;
	dfn[u]=low[u]=++dn;
	sta[++top]=u;
	insta[u]=1;
	for (int i=head[u]; ~i; i=edge[i].next) {
		int v=edge[i].t;
		if (!dfn[v]) {
			tarjan(v);
			low[u]=min(low[u], low[v]);
		} else if (insta[v])// 返祖边和横插边
			low[u]=min(low[u], dfn[v]);
	}
	if (dfn[u]==low[u]) {
		++cn;
		for (int v=-1; v!=u;) {
			v=sta[top--];
			insta[v]=0;
			color[v]=cn;
		}
	}
}
void converge(int n) {
	fill_n(dfn+1,n,0), dn=cn=0;
	for(int i=1; i<=n; ++i)
		if(!dfn[i])
			tarjan(i);
}

namespace NetFlow {
    using T=int;
	const T INF=T(1)<<(sizeof(T)*8-2);
    const int _V=N;
    const int _E=1000000*2+10;
	int s0=_V-1,t0=s0-1;
    int head[_V],en;
	struct ty {
		int t, next;
        T l;
	} edge[_E];
    void initGraph() {
		memset(head, -1, sizeof(head)), en=0;
	}
	void addEdge(int x, int y, T z=0) {
		edge[en]= {y, head[x], z};
        head[x]=en++;
		if(en&1) addEdge(y, x);
	}
    int dis[_V];
	bool bfs(int s,int t) {
        memset(dis,-1,sizeof dis);
	    queue<int> q;
        dis[s]=0;
		q.push(s);
		while(q.size()) {
			int u=q.front();
			q.pop();
			for (int i=head[u]; ~i; i=edge[i].next) {
				int v=edge[i].t;
				if(dis[v]==-1&&edge[i].l>0) {
					dis[v]=dis[u]+1;
					q.push(v);
				}
			}
		}
		return dis[t]!=-1;
	}
	T dfs(int u, T flow,int t) {
		if(u==t) return flow;
		T ans=flow;
		for (int i=head[u]; ~i&&ans; i=edge[i].next) {
			int v=edge[i].t;
			if (dis[v]==dis[u]+1&&edge[i].l>0) {
				T tmp=dfs(v, min(edge[i].l, ans), t);
				edge[i].l-=tmp;
				edge[i^1].l+=tmp;
				ans-=tmp;
			}
		}
		if(ans==flow) dis[u]=-1;
		return flow-ans;
	}
	T dinic(int s,int t) {
		T ans=0;
		while(bfs(s,t)) ans+=dfs(s,INF,t);
		return ans;
	}
    void printGraph() {
        auto dot=[&](int u)->string{
            if(u==s0) return "S";
            if(u==t0) return "T";
            return to_string(u);
        };
		cerr<<endl<<"Graph with "<<en<<" edges:"<<endl;
        for(int i=0; i<en; ++i) {
            int u=edge[i^1].t, v=edge[i].t;
            T w=edge[i].l;
            cerr<<dot(u)<<" -> "<<dot(v)<<" : ";
            cerr<<(w==INF?"INF":to_string(w))<<endl;
        }
    }
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin>>n>>m;
    Graph::initGraph(n);
    vector<pair<int,int>> edg;
    while(m--) {
        int u,v;
        cin>>u>>v;
        Graph::addEdge(u,v);
        edg.emplace_back(u,v);
    }
    converge(n);
	debug_n(color+1,n);
    
    // 缩点之后跑网络流
	using namespace NetFlow;
	initGraph();
	for(int i=1; i<=cn; ++i) {
		addEdge(s0,i+cn,1);
		addEdge(i,t0,1);
	}
	for(auto [u,v]:edg) {
		int x=color[u];
		int y=color[v];
		if(x==y) continue;
		addEdge(x+cn,y,1);
		addEdge(x+cn,y+cn,INF);// 向所有能到的点连边
	}

	int flow=dinic(s0,t0);

	vector<int> paint(cn+1);
	for(int u=1,c=0; u<=cn; ++u) {
		// 找前驱
		int flag=0;
		for(int i=head[u]; ~i; i=edge[i].next) {
			int v=edge[i].t;
			auto w=edge[i].l;
			if(v!=s0 && (i&1) && w==1) {
				flag=1;
				break;
			}
		}
		if(flag) continue;
		// debug(u);

		// 没有前驱，标颜色
		paint[u]=++c;
		for(int now=u; now;) {
			debug(now);
			int nxt=0;
			for(int i=head[now+cn]; ~i; i=edge[i].next) {
				if(i&1) continue;
				int v=edge[i].t, w=edge[i].l;
				if(edge[i^1].l==0) continue;
				debug(now,v);

				// vis[i]=1;
				// head[now+cn]=edge[i].next;
				edge[i].l+=1;
				edge[i^1].l-=1;
				if(v>cn) {
					nxt=v-cn;
					break;
				}else if(paint[v]) {
					continue;
				}else {
					paint[v]=c;
					nxt=v;
					break;
				}
			}
			now=nxt;
		}
	}

	for(int i=1; i<=n; ++i) 
		cout<<paint[color[i]]<<" ";
    return 0;
}
/*




*/