#include <bits/stdc++.h>

using namespace std;
using lint = int64_t;

struct scc_t{
    int n, t, scc_num;
    vector<vector<int>> adj;
    vector<int> low, id, stk, in_stk, cc_id;
    scc_t(const vector<vector<int>> & g) : n(int(g.size())), t(0), scc_num(0),
    adj(g), low(n, -1), id(n, -1), in_stk(n, false), cc_id(n){}
    template<class F> void dfs(int cur, F f){
        id[cur] = low[cur] = t++;
        stk.push_back(cur);
        in_stk[cur] = true;
        for(int nxt : adj[cur]){
            if(id[nxt] == -1){
                dfs(nxt, f);
                low[cur] = min(low[cur], low[nxt]);
            } else if(in_stk[nxt])
                low[cur] = min(low[cur], id[nxt]);
        }
        if(low[cur] == id[cur]){
            vector<int> cc; cc.reserve(stk.size());
            while(true){
                int v = stk.back(); stk.pop_back();
                in_stk[v] = false;
                cc.push_back(v);
                cc_id[v] = scc_num;
                if(v == cur) break;
            } f(cc); scc_num++;
        }
    }
    template<class F> void solve(F f){
        stk.reserve(n);
        for(int r =0 ; r< n; ++r)
            if(id[r] == -1) dfs(r, f);
    }
};

struct bipartite_matching{
    int N,M,T;
    vector<vector<int>> adj;
    vector<int> match, seen;
    bipartite_matching(int a, int b) : N(a), M(a+b), adj(M), match(M, -1), seen(M, -1), T(0){}
    void add_edge(int a, int b){
        assert(0 <= a && a < N && b + N < M && N <= b + N);
        adj[a].push_back(b + N);
    }
    void shuffle_edges(){
        mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
        for(auto& cur : adj)
            shuffle(cur.begin(), cur.end(), rng);
    }
    bool dfs(int cur){
        if(seen[cur] == T) return false;
        seen[cur] = T;
        for(int nxt : adj[cur])
            if(match[nxt] == -1){
                match[nxt] = cur, match[cur] = nxt;
                return true;
            }
        for(int nxt : adj[cur])
            if(dfs(match[nxt])){
                match[nxt] = cur, match[cur] = nxt;
                return true;
            }
        return false;
    }
    int solve(){
        int res = 0;
        while(true){
            int cur = 0; ++T;
            for(int i=0; i<N; ++i)
                if(match[i] == -1) cur += dfs(i);
            if(cur == 0) break;
            else res += cur;
        }
        return res;
    }
};

using pii = pair<int, int>;

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, m;
    cin>>n>>m;
    vector<int> in_degree(n);
    vector<pii> edges(m);
    vector<vector<int>> g(n);

    for(auto &[u, v] : edges){
        cin>>u>>v;
        u--, v--;
        g[u].push_back(v);
    }
    scc_t scc(g);
    scc.solve([](const vector<int> &x){});
    vector<vector<int>> dag(scc.scc_num);
    set<pii> dag_edges;
    {        
        for(const auto &[u, v] : edges){
            int a = scc.cc_id[u], b = scc.cc_id[v];
            if(a != b && !dag_edges.count({a, b})){
                dag[a].push_back(b);
                dag_edges.insert({a, b});
            }
        }
        // for(int u =0; u<n; u++){
        //     cout<<u<<" comp "<<scc.cc_id[u]<<"\n";
        // }
        // cout<<"dag edges \n";
        // for(const auto &[u, v] : dag_edges){
        //     cout<<u<<" "<<v<<"\n";
        // }
    }
    bipartite_matching match(scc.scc_num, scc.scc_num);
    /*
    0 -- 0
    */
    for(const auto &[u, v] : dag_edges){
        match.add_edge(u, v);
    }
    int maxi = match.solve();
    // cout<<" match "<<maxi<<"\n";
    // cout<<scc.scc_num - maxi<<"\n";

    vector<int> color(scc.scc_num, -1);
    int current_color = 1;

    // for(int i=0; i<scc.scc_num; i++){
    //     cout<<"s"<<i<<" math com s"<<match.match[i+scc.scc_num]<<"\n";
    // }
    for(int i=0; i<scc.scc_num; i++){

        if(match.match[i+scc.scc_num] == -1){
            color[i] = current_color;
            int cur = i; // T
            int mat = match.match[cur]; //S
            while(mat != -1){
                cur = mat - scc.scc_num; // T
                color[cur] = current_color;
                mat = match.match[cur]; // S
            }
            current_color++;
        }
    }
    vector<int> ans(n);
    for(int i=0; i<n; i++){
        ans[i] = color[scc.cc_id[i]];
        cout<<ans[i]<<" ";
    }
    cout<<"\n";



    return 0;
}