#pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
#define all(x) begin(x),end(x)
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { string sep; for (const T &x : v) os << sep << x, sep = " "; return os; }
#define debug(a) cerr << "(" << #a << ": " << a << ")\n";
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pi;
const int mxN = 1e5+1, oo = 1e9;

struct SCC {
    vvi adj, rev,dag;
    vi order, order2;
    vi boss;
    vector<bool> visited;
    vector<bitset<7000>> reach;
    int n;
    #define rs(a) a.resize(n)
    SCC(int nn) {
        n=nn;
        rs(adj),rs(rev),rs(boss),rs(visited);
    }
    void addEdge(int a, int b) {
        adj[a].push_back(b);
        rev[b].push_back(a);
    }
    void dfs1(int at) {
        visited[at] = true;
        for(int to: adj[at]) if(!visited[to]) dfs1(to);
        order.push_back(at);
    }
    int id;
    void dfs2(int at) {
        visited[at] = true;
        boss[at] = id;
        order2.push_back(at);
        for(int to: rev[at]) if(!visited[to]) dfs2(to);
    }
    vector<bitset<7000>> run() {
        for(int i=0;i<n;++i) 
            if(!visited[i]) 
                dfs1(i);
        fill(all(visited),false);
        reverse(all(order));
        id=0;
        
        for(int i: order) {
            if(!visited[i]) {
                dfs2(i),id++;
            }
        }
        reach.resize(id);
        dag.resize(id);
        for(int i=0;i<n;++i) for(int to : adj[i]) {
            dag[boss[i]].push_back(boss[to]);
        }

        fill(all(visited),0);
        for(int i=0;i<id;++i) {
            if(!visited[i]) {
                auto dfsd = [&](auto&& self, int at) -> void {
                    visited[at]=1;
                    reach[at][at]=1;
                    for(int to : dag[at]) {
                         if(!visited[to])  {
                            self(self,to);
                            
                        }
                        reach[at]|=reach[to];
                    }
                };
                dfsd(dfsd,i);
            }
        }
        for(int i=0;i<id;++i) reach[i][i]=0;
        return reach;
    }
};
struct HopcroftKarp {

    const int N, M;
    std::vector<bitset<7000>> adj_left;
    std::vector<int> matchL, matchR;

    HopcroftKarp (int N, int M, vector<bitset<7000>> adj)
    : N(N), M(M), matchL(N, -1), matchR(M, -1), adj_left(adj) {
    }

    int maxmatching () {
        int sz = 0;
        for(int u=0;u<N;++u)  {
             for(int v=adj_left[u]._Find_next(u);v<M;v=adj_left[u]._Find_next(v)) {
                if(matchR[v]==-1) {
                    matchL[u]=v;
                    matchR[v]=u;
                    sz++;
                    break;
                }
             }
        }
        for (bool updated = true; updated; ) {
            updated = false;

            static std::vector<int> root(N), prev(N), qq(N);
            static int qi, qj;

            // std::queue<int> q;

            qi = qj = 0;
            std::fill(root.begin(), root.end(), -1),
            std::fill(prev.begin(), prev.end(), -1);

            for (int i = 0; i < N; i++)
                if (matchL[i] == -1)
                    qq[qj++] = i, root[i] = i, prev[i] = i;
                    // q.push(i), root[i] = i;

            while (qi < qj) {
                int u = qq[qi++];
                // int u = q.front(); q.pop();
                if (matchL[root[u]] != -1) continue;

                for(int v=adj_left[u]._Find_next(u);v<M;v=adj_left[u]._Find_next(v)) {
                    if (matchR[v] == -1) {
                        while (v != -1)
                            matchR[v] = u, std::swap(matchL[u], v), u = prev[u];
                        
                        updated = true, sz++;
                        break;
                    }

                    if (prev[matchR[v]] == -1)
                        v = matchR[v], prev[v] = u, root[v] = root[u], qq[qj++] = v;
                        // v = matchR[v], prev[v] = u, root[v] = root[u], q.push(v);
                }
            }
        }

        return sz;
    }

};
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int n,m; cin >> n >> m;
    SCC scc(n);
    while(m--) {
        int u,v; cin >> u >> v;
        --u,--v;
        scc.addEdge(u,v);
    }
    
    auto es = scc.run();
    HopcroftKarp hp(scc.id,scc.id, es);
    hp.maxmatching();
    vector<bool> vis(n);
    int col=1;
    vi cl(scc.id);
    for(int i=0;i<scc.id;++i) {
        if(!vis[i]) {
            cl[i]=col++;    
        }
        int to = hp.matchL[i];
        if(to!=-1) cl[to]=cl[i],vis[to]=1;
    }
    vi ans(n);
    for(int i=0;i<n;++i) {
        ans[i] = cl[scc.boss[i]];
    }
    cout << ans << '\n';
}