#include <bits/stdc++.h>
using namespace std;
#define fastIO ios::sync_with_stdio(0), cin.tie(0)
#define endl '\n'
#define ft first
#define sd second
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define len(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define read(x) for(auto &el : x) cin >> el;
#define print(x) for(auto &el : x) {cout << el << " ";} cout << endl;
#define printR(x, ini, n) for(int i = ini; i < n; i++) { if(i != ini) {cout << " ";}; cout << x[i];}; cout << endl;
typedef long long ll;
typedef pair<int,int> pii;
// scanf("%d %d %d %d",&w,&b,&d,&s); %lld
// printf("%d\n" ,points);
// const double PI = acos(-1);

inline int add(int a, int b, const int &mod) { return a+b >= mod ? a+b-mod : a+b; }
inline int sbt(int a, int b, const int &mod) { return a-b < 0 ? a-b+mod : a-b; }
inline int mul(int a, int b, const int &mod) { return 1ll*a*b % mod; }

struct edge { int v, cap, inv, flow; bool rev; };

struct network {
    int n, s, t;
    vector<int> lvl;
    vector<vector<edge>> g;

    network(int n) : n(n), lvl(n), g(n) {}

    void add_edge(int u, int v, int c) {
        g[u].pb({v, c, (int)g[v].size(), 0, false});
        g[v].pb({u, 0, (int)g[u].size()-1, c, true});
    }

    bool bfs() {
        fill(lvl.begin(), lvl.end(), -1);
        queue<int> q;
        lvl[s] = 0;
        for (q.push(s); q.size(); q.pop()) {
            int u = q.front();
            for (auto &e : g[u]) {
                if (e.cap > 0 && lvl[e.v] == -1) {
                    lvl[e.v] = lvl[u]+1;
                    q.push(e.v);
                }
            }
        }
        return lvl[t] != -1;
    }

    int dfs(int u, int nf) {
        if (u == t) return nf;
        int res = 0;
        for (auto &e : g[u]) {
            if (e.cap > 0 && lvl[e.v] == lvl[u]+1) {
                int tf = dfs(e.v, min(nf, e.cap));
                res += tf; nf -= tf; e.cap -= tf;
                g[e.v][e.inv].cap += tf;
                g[e.v][e.inv].flow -= tf;
                e.flow += tf;
                if (nf == 0) return res;
            }
        }
        if (!res) lvl[u] = -1;
        return res;
    }

    int max_flow(int so, int si, int res = 0) {
        s = so; t = si;
        while (bfs()) res += dfs(s, INT_MAX);
        return res;
    }
    
    vector<pii> edges;
    
    int find_path(int u, int p = 0) {
    	if (u == n - 1) {
    		return p;
    	}
    	for (auto &[v, cap, inv, flow, rev] : g[u]) {
    		if (!rev && flow) {
    			flow--;
    			return find_path(v, u);
    		}
    	}
    	return -1;
    }
    
    void build_chains() {
    	int sz = n / 2 - 1;
    	for (auto &[u, cap, inv, flow, rev] : g[0]) {
    		if (flow) {
    			edges.pb({u, find_path(u) - sz});
    		}
    	}
    }
};

const int inf = 1e9;
const int MX = 7e3+5;
vector<int> g[MX];
set<int> dag[MX];
stack<int> st;
int low[MX], pre[MX], cnt;
int degree[MX], nxt[MX];
int color[MX];
int comp[MX], SCC;
int n, m;

void tarjan(int u) {
    low[u] = pre[u] = cnt++;
    st.push(u);
    for (auto &v : g[u]) {
        if (pre[v] == -1) tarjan(v);
        low[u] = min(low[u], low[v]);
    }
    if (low[u] == pre[u]) {
        SCC++;
        while (true) {
            int v = st.top(); st.pop();
            low[v] = inf;
            comp[v] = SCC;
            if (u == v) break;
        }
    }
}

void init() {
    cnt = SCC = 0;
    for (int i = 0; i <= n; i++) {
        g[i].clear();
        pre[i] = -1; 
    }
}

int main() {
    fastIO;
    cin >> n >> m;
    init();
    for (int i = 0, u, v; i < m; ++i) {
    	cin >> u >> v;
    	g[u].pb(v);
    }
    for (int i = 1; i <= n; ++i) {
    	
    	if (pre[i] == -1) {
    		tarjan(i);
    	}
    }
    for (int u = 1; u <= n; ++u) {
    	for (int &v : g[u]) {
    		if (comp[u] != comp[v]) {
    			dag[comp[u]].insert(comp[v]);
    		}
    	}
    }
    network nf(2 * (SCC + 1));
    for (int u = 1; u <= SCC; ++u) {
    	nf.add_edge(0, u, 1);
    	nf.add_edge(u + SCC, 2 * SCC + 1, 1);
    	nf.add_edge(u + SCC, u, inf);
    	for (auto &v : dag[u]) {
    		nf.add_edge(u, v + SCC, inf);
    	}
    }
    int mx_f = nf.max_flow(0, 2 * SCC + 1);
    // cout << SCC - mx_f << endl;
    nf.build_chains();
    for (auto &[u, v] : nf.edges) {
    	nxt[u] = v;
    	degree[v]++;
    }
    queue<int> q;
    for (int u = 1; u <= SCC; ++u) {
    	if (degree[u] == 0) {
    		q.push(u);
    	}
    }
    int u, c = 0;
    while (!q.empty()) {
    	u = q.front();
    	q.pop();
    	
    	++c;
    	while (u) {
    		color[u] = c;
    		u = nxt[u];
    	}
    }
    assert(c == SCC - mx_f);
    for (int i = 1; i <= n; ++i) {
    	if (i > 1) cout << " ";
    	cout << color[comp[i]];
    }
    cout << endl;
    return 0;
}