#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair < int , int > pii ;
typedef vector<int> vi;
#define fi first
#define se second
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());

#define MAXN 15007
#define inf 1000000007

namespace flow {
    int n ;
    int source ;
    int sink ;
    struct tuhla {
        int to ;
        int flow , cap ;
        int rev ;
        tuhla ( ) { to = flow = cap = rev = 0 ; }
        tuhla ( int _to , int _cap , int _rev ) {
            to = _to , cap = _cap , flow = 0 , rev = _rev ;
        }
    };
    vector < tuhla > v[ MAXN ] ;
    int sz[ MAXN ] ;
    int lvl[ MAXN ] ;
    int pos[ MAXN ] ;
    void add_edge ( int x , int y , int cap ) {
        v[ x ].push_back ( tuhla ( y , cap , sz[ y ] ) ) ;
        v[ y ].push_back ( tuhla ( x , 0 , sz[ x ] ) ) ;
        ++ sz[ x ] , ++ sz[ y ] ;
    }
    bool bfs ( int st ) {
        queue < int > q ;
        for ( int i = 1 ; i <= n ; ++ i ) {
            lvl[ i ] = pos[ i ] = 0 ;
        }
        lvl[ st ] = 1 ;
        q.push ( st ) ;
        while ( !q.empty ( ) ) {
            int x = q.front ( ) ;
            q.pop ( ) ;
            for ( int i = 0 ; i < sz[ x ] ; ++ i ) {
                if ( lvl[ v[ x ][ i ].to ] == 0 && v[ x ][ i ].flow != v[ x ][ i ].cap ) {
                    lvl[ v[ x ][ i ].to ] = lvl[ x ] + 1 , q.push ( v[ x ][ i ].to ) ;
                }
            }
        }
        return ( lvl[ sink ] != 0 ) ;
    }
    int dfs ( int vertex , int curr ) {
        if ( curr == 0 || vertex == sink ) { return curr ; }
        for ( ; pos[ vertex ] < sz[ vertex ] ; ++ pos[ vertex ] ) {
            if ( lvl[ v[ vertex ][ pos[ vertex ] ].to ] == lvl[ vertex ] + 1 ) {
                int aux = dfs ( v[ vertex ][ pos[ vertex ] ].to , min ( curr , v[ vertex ][ pos[ vertex ] ].cap - v[ vertex ][ pos[ vertex ] ].flow ) ) ;
                v[ vertex ][ pos[ vertex ] ].flow += aux ;
                v[ v[ vertex ][ pos[ vertex ] ].to ][ v[ vertex ][ pos[ vertex ] ].rev ].flow -= aux ;
                if ( aux > 0 ) { return aux ; }
            }
        }
        return 0 ;
    }
    long long maxflow ( ) {
        long long maxflow = 0 ;
        while ( bfs ( source ) == true ) {
            while ( 1 ) {
                int flow = dfs ( source , inf ) ;
                if ( flow == 0 ) { break ; }
                maxflow += flow ;
            }
        }
        return maxflow ;
    }
}


int n , m ;
vector < int > gr[ MAXN ] , rv[ MAXN ] ;
int used[ MAXN ] , scc[ MAXN ] ;

stack < int > st ;

void dfs ( int x ) {
    used[ x ] = 1 ;
    for ( auto y : gr[ x ] ) {
        if ( used[ y ] == 0 ) {
            dfs ( y ) ;
        }
    }
    st.push ( x ) ;
}

void rev_dfs ( int x , int id ) {
    scc[ x ] = id ;
    for ( auto y : rv[ x ] ) {
        if ( scc[ y ] == 0 ) {
            rev_dfs ( y , id ) ;
        }
    }
}

set < int > s[ MAXN ] ;

int prv[ MAXN ] , rnk[ MAXN ] ;

int get ( int x ) {
    if ( prv[ x ] == -1 ) { return x ; }
    int y = get ( prv[ x ] ) ;
    prv[ x ] = y ;
    return y ;
}

void unite ( int x , int y ) {
    int k1 = get ( x ) , k2 = get ( y ) ;
    if ( k1 == k2 ) { return ; }
    if ( rnk[ k1 ] >= rnk[ k2 ] ) {
        rnk[ k1 ] += ( rnk[ k1 ] == rnk[ k2 ] ) ;
        prv[ k2 ] = k1 ;
    }
    else {
        prv[ k1 ] = k2 ;
    }
}

map < int , int > col ;

void solve ( ) {
    cin >> n >> m ;
    for ( int i = 1 , x , y ; i <= m ; ++ i ) {
        cin >> x >> y ;
        gr[ x ].push_back ( y ) ;
        rv[ y ].push_back ( x ) ;
    }
    for ( int i = 1 ; i <= n ; ++ i ) {
        if ( used[ i ] == 0 ) {
            dfs ( i ) ;
        }
    }
    int tp = 0 ;
    while ( st.empty ( ) == false ) {
        int x = st.top ( ) ; st.pop ( ) ;
        if ( scc[ x ] > 0 ) { continue ; }
        rev_dfs ( x , ++ tp ) ;
    }
    for ( int i = 1 ; i <= n ; ++ i ) {
        for ( auto j : gr[ i ] ) {
            if ( scc[ i ] != scc[ j ] && s[ scc[ i ] ].find ( scc[ j ] ) == s[ scc[ i ] ].end ( ) ) {
                s[ scc[ i ] ].insert ( scc[ j ] ) ;
            }
        }
    }
    flow :: n = flow :: sink = 2 * tp + 2 ;
    flow :: source = 2 * tp + 1 ;
    for ( int i = 1 ; i <= tp ; ++ i ) {
        flow :: add_edge ( flow :: source , i , 1 ) ;
        flow :: add_edge ( tp + i , flow :: sink , 1 ) ;
        for ( auto j : s[ i ] ) {
            flow :: add_edge ( i , j , inf ) ;
            flow :: add_edge ( i , tp + j , 1 ) ;
        }
    }
    ll ans = flow :: maxflow ( ) ;
    // cout << tp - ans << "\n" ;
    for ( int i = 1 ; i <= tp ; ++ i ) {
        prv[ i ] = -1 , rnk[ i ] = 0 ;
    }
    for ( int i = 1 ; i <= tp ; ++ i ) { 
        for ( auto e : ( flow :: v[ i ] ) ) {
            if ( e.flow > 0 && ( tp < e.to && e.to <= 2 * tp ) ) {
                unite ( i , e.to - tp ) ;
            }
        }
    }
    int mxcol = 0 ;
    for ( int i = 1 ; i <= tp ; ++ i ) {
        int root = get ( i ) ;
        if ( col[ root ] == 0 ) {
            col[ root ] = ++ mxcol ;
        }
    }
    for ( int i = 1 ; i <= n ; ++ i ) {
        cout << col[ get ( scc[ i ] ) ] << " " ;
    }
    cout << "\n" ;
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    int t = 1 ; // cin >> t ; 
    while ( t -- ) { solve ( ) ; }
    return 0 ;
}