#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#ifdef APURBA
#include "DEBUG_TEMPLATE.h"
#else
#define HERE
#define debug(args...)
#endif
#define ALL(x) x.begin(),x.end()
const int N = 7e3 +5;
typedef pair<int,int> pii;


int n,m;
vector<int> g[N], gr[N];
vector<bool> used;
vector<int> order, component;

void dfs1 (int v)
{
    used[v] = true;
    for (size_t i=0; i<g[v].size(); ++i)
        if (!used[ g[v][i] ])
            dfs1 (g[v][i]);
    order.push_back (v);
}

void dfs2 (int v)
{
    used[v] = true;
    component.push_back (v);
    for (size_t i=0; i<gr[v].size(); ++i)
        if (!used[ gr[v][i] ])
            dfs2 (gr[v][i]);
}

struct bipartite_matching {
    int n_left, n_right, flow = 0;
    bitset<N>g[N];
    std::vector<int> match_from_left, match_from_right;

    bipartite_matching(int _n_left, int _n_right)
        : n_left(_n_left),
          n_right(_n_right),
          match_from_left(_n_left, -1),
          match_from_right(_n_right, -1),
          dist(_n_left) {}


    std::vector<int> dist;

    void bfs() {
        std::queue<int> q;
        for (int u = 0; u < n_left; ++u) {
            if (!~match_from_left[u])
                q.push(u), dist[u] = 0;
            else
                dist[u] = -1;
        }
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for(int v=g[u]._Find_first(); v< g[u].size(); v = g[u]._Find_next(v))
                if (~match_from_right[v] && !~dist[match_from_right[v]]) {
                    dist[match_from_right[v]] = dist[u] + 1;
                    q.push(match_from_right[v]);
                }
        }
    }

    bool dfs(int u) {
        for(int v=g[u]._Find_first(); v< g[u].size(); v = g[u]._Find_next(v))
            if (!~match_from_right[v]) {
                match_from_left[u] = v, match_from_right[v] = u;
                return true;
            }
        for(int v=g[u]._Find_first(); v< g[u].size(); v = g[u]._Find_next(v))
            if (dist[match_from_right[v]] == dist[u] + 1 &&
                dfs(match_from_right[v])) {
                match_from_left[u] = v, match_from_right[v] = u;
                return true;
            }
        return false;
    }

    int get_max_matching() {
        while (true) {
            bfs();
            int augment = 0;
            for (int u = 0; u < n_left; ++u)
                if (!~match_from_left[u]) augment += dfs(u);
            if (!augment) break;
            flow += augment;
        }
        return flow;
    }

    std::pair<std::vector<int>, std::vector<int>> minimum_vertex_cover() {
        std::vector<int> L, R;
        for (int u = 0; u < n_left; ++u) {
            if (!~dist[u])
                L.push_back(u);
            else if (~match_from_left[u])
                R.push_back(match_from_left[u]);
        }
        return {L, R};
    }

    std::vector<std::pair<int, int>> get_edges() {
        std::vector<std::pair<int, int>> ans;
        for (int u = 0; u < n_left; ++u)
            if (match_from_left[u] != -1)
                ans.emplace_back(u, match_from_left[u]);
        return ans;
    }
};


int head[N];
vector<int>adj[N];
int color[N];

void dfs3(int s, bipartite_matching &bm)
{
    used[s] = 1;
    for(int i:adj[s])
    {
        if(!used[i])
        {
            dfs3(i , bm);
        }
        bm.g[s] |= bm.g[i];
        bm.g[s][i] = 1;
    }
    bm.g[s][s] = 0;
}

struct DSU
{
    vector<int>parent;
    vector<int>rnk;
    int n;
    DSU(int nn)
    {
        n=nn;
        parent.resize(n);
        rnk.resize(n);
        for(int i=0; i<n; i++)
        {
            make_set(i);
        }
    }
    void make_set(int x)
    {
        rnk[x] = 0;
        parent[x] = x;
    }
    int find_set(int x)
    {
        if(parent[x]!=x)
        {
            parent[x] = find_set(parent[x]);
        }
        return parent[x];
    }
    void Union(int u,int v)
    {
        int p= find_set(u),q=find_set(v);
        if(p==q)
            return;
        if( rnk[p] > rnk[q])
            swap(p,q);
        parent[p]= q;
        if(rnk[p]==rnk[q])
        {
            rnk[q] +=1;
        }
    }
};


int32_t main()
{
#ifndef APURBA
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#endif
    int n,m;
    cin>>n>>m;
    for(int i=0; i<m; i++)
    {
        int a, b;
        cin>>a>>b;
        a--;
        b--;
        g[a].push_back(b);
        gr[b].push_back(a);
    }

    used.assign (n, false);
    for (int i=0; i<n; ++i)
        if (!used[i])
            dfs1 (i);
    used.assign (n, false);
    int id = 0;
    for (int i=0; i<n; ++i)
    {
        int v = order[n-1-i];
        if (!used[v])
        {
            dfs2 (v);
            for(int j:component)
                head[j] = id;
            id++;
            component.clear();
        }
    }
    for(int i=0; i<n; i++)
    {
        for(int j:g[i])
        {
            if(head[i]!=head[j])
                adj[head[i]].push_back(head[j]);
        }
    }
    for(int i=0; i<n; i++)
    {
        sort(adj[i].begin(),adj[i].end());
        adj[i].resize(unique(adj[i].begin(),adj[i].end()) - adj[i].begin() );
        g[i].clear();
        gr[i].clear();
        debug(i,adj[i]);
    }
    used.clear();
    order.clear();
    bipartite_matching bm(id,id);

    used.assign(id, 0);
    for(int i=0;i<id;i++)
    {
        if(used[i])
            continue;
        dfs3(i,bm);
    }
    bm.get_max_matching();
    vector<pii>lol = bm.get_edges();
    DSU d(id);
    for(auto it:lol)
    {
        d.Union(it.first, it.second);
    }
    int bosa = 1;
    for(int i=0;i<id;i++)
    {
        if(d.find_set(i) == i)
        {
            color[i] = bosa;
            bosa++;
        }
    }
    for(int i=0; i<n; i++)
    {
        cout<<color[d.find_set(head[i])]<<" ";
    }

    return 0;
}
/*
5 5
1 4
2 3
1 3
2 5
5 1


*/