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

const int MAXN = 6e5 + 7 ;
const int LOG = 21 ;

int n ;
vector < int > v[ MAXN ] ;
int prv[ MAXN ] , lvl[ MAXN ] ;


int st[ MAXN ] , en[ MAXN ] ;
int fst[ MAXN ] ;
vector < int > sparse_ord ;
vector < int > ord ;

void dfs ( int x , int lst ) {
    prv[ x ] = lst ;
    ord.push_back ( x ) ;
    st[ x ] = ord.size ( ) ;
    
    sparse_ord.push_back ( x ) ;
    fst[ x ] = sparse_ord.size ( ) ;
    for ( auto y : v[ x ] ) {
        if ( y == lst ) { continue ; }
        lvl[ y ] = lvl[ x ] + 1 ;
        dfs ( y , x ) ;
        sparse_ord.push_back ( x ) ;
    }
    en[ x ] = ord.size ( ) ;
}

int tab[ MAXN ][ LOG ] ;
int mxst[ MAXN ] ;

int get_lca ( int x , int y ) {
    int pos1 = fst[ x ] , pos2 = fst[ y ] ;
    if ( pos1 > pos2 ) { swap ( pos1 , pos2 ) ; }
    int len = pos2 - pos1 + 1 ;
    int id = mxst[ len ] ;
    int cand1 = tab[ pos1 ][ id ] ;
    int cand2 = tab[ pos2 - ( 1 << id ) + 1 ][ id ] ;
    if ( lvl[ cand1 ] < lvl[ cand2 ] ) { return cand1 ; }
    return cand2 ;
}

vector < pii > at_val[ MAXN ] ;

class Tree {
public :
    int tr[ 4 * MAXN ] ;
    void init ( int w , int l , int r ) {
        tr[ w ] = 0 ;
        if ( l == r ) { return ; }
        int mid = ( l + r ) / 2 ;
        init ( 2 * w , l , mid ) ;
        init ( 2 * w + 1 , mid + 1 , r ) ;
    }
    void update ( int w , int l , int r , int pos , int add ) {
        tr[ w ] += add ;
        if ( l == r ) { return ; }
        int mid = ( l + r ) / 2 ;
        if ( pos <= mid ) { update ( 2 * w , l , mid , pos , add ) ; }
        else { update ( 2 * w + 1 , mid + 1 , r , pos , add ) ; }
    }
    int query ( int w , int l , int r , int st , int en ) {
        if ( l > r || st > en ) { return 0 ; }
        if ( r < st || en < l ) { return 0 ; }
        if ( st <= l && r <= en ) { return tr[ w ] ; }
        int mid = ( l + r ) / 2 ;
        return query ( 2 * w , l , mid , st , en ) + query ( 2 * w + 1 , mid + 1 , r , st , en ) ;
    }
};
Tree w ;

ll ans[ MAXN ] ;
ll passing[ MAXN ] ;
ll ending_at[ MAXN ] ;
ll going_up[ MAXN ] ;
ll at_lca[ MAXN ] ;

ll finished[ MAXN ] ;

void dfs_down ( int x , int lst ) {
    for ( auto y : v[ x ] ) {
        if ( y == lst ) { continue ; }
        dfs_down ( y , x ) ;
        finished[ x ] += finished[ y ] ;
        finished[ x ] += ending_at[ y ] ;
    }
}

void dfs_up ( int x , int lst , ll up ) {
    // printf ( "-- %d %d %lld\n" , x , lst , up ) ;
    ans[ x ] = finished[ x ] + up + passing[ x ] ;
    ll sm = 0 ;
    for ( auto y : v[ x ] ) {
        if ( y == lst ) { continue ; }
        sm += finished[ y ] ;
        sm += ending_at[ y ] ;
    }
    for ( auto y : v[ x ] ) {
        if ( y == lst ) { continue ; }
        sm -= finished[ y ] ;
        sm -= ending_at[ y ] ;

        dfs_up ( y , x , up + sm + passing[ x ] - going_up[ y ] ) ;
        
        sm += finished[ y ] ;
        sm += ending_at[ y ] ;        
    }
}

void solve ( ) {
    cin >> n ;
    for ( int i = 1 , x , y ; i < n ; ++ i ) {
        cin >> x >> y ;
        v[ x ].push_back ( y ) ;
        v[ y ].push_back ( x ) ;
    }
    dfs ( 1 , -1 ) ;
    int sz = sparse_ord.size ( ) ;
    for ( int i = 1 ; i <= sz ; ++ i ) {
        tab[ i ][ 0 ] = sparse_ord[ i - 1 ] ;
    }
    for ( int k = 1 ; k < LOG ; ++ k ) {
        for ( int i = 1 ; i + ( 1 << k ) - 1 <= sz ; ++ i ) {
            int x = tab[ i ][ k - 1 ] , y = tab[ i + ( 1 << ( k - 1 ) ) ][ k - 1 ] ;
            if ( lvl[ x ] < lvl[ y ] ) {
                tab[ i ][ k ] = x ;
            }
            else {
                tab[ i ][ k ] = y ;
            }
        }
    }
    mxst[ 1 ] = 0 ;
    int len = 0 ;
    for ( int i = 2 ; i <= sz ; ++ i ) {
        while ( 2 * ( 1 << len ) < i ) { ++ len ; }
        mxst[ i ] = len ;
    }

    /**
    for ( int i = 1 ; i <= n ; ++ i ) {
        for ( int j = 1 ; j <= n ; ++ j ) {
            printf ( "lca ( %d , %d ) = %d\n" , i , j , get_lca ( i , j ) ) ;
        }
    }
    **/
    for ( ll i = 1 ; i <= n ; ++ i ) {
        for ( ll j = i * i ; j <= n ; j += i ) {
            at_val[ j ].push_back ( { i , j / i } ) ;
        }
    }
    w.init ( 1 , 1 , n ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        passing[ i ] = w.query ( 1 , 1 , n , st[ i ] , en[ i ] ) ;
        ending_at[ i ] = at_lca[ i ] ;
        // going_up[ i ] = passing[ i ] - ending_at[ i ] ;
        for ( auto child : v[ i ] ) {
            if ( child == prv[ i ] ) { continue ; }
            going_up[ child ] = w.query ( 1 , 1 , n , st[ child ] , en[ child ] ) - at_lca[ child ] ;
        }
        // printf ( "%lld %lld %lld\n" , passing[ i ] , ending_at[ i ] , going_up[ i ] ) ;
        for ( auto [ x , y ] : at_val[ i ] ) {
            int aux = get_lca ( x , y ) ;
            ++ at_lca[ aux ] ;
            w.update ( 1 , 1 , n , st[ x ] , 1 ) ;
            w.update ( 1 , 1 , n , st[ y ] , 1 ) ;
            w.update ( 1 , 1 , n , st[ aux ] , -1 ) ;
            if ( prv[ aux ] != -1 ) {
                w.update ( 1 , 1 , n , st[ prv[ aux ] ] , -1 ) ;
            }
        }
    }
    dfs_down ( 1 , -1 ) ;
    /**
    for ( int i = 1 ; i <= n ; ++ i ) {
        printf ( "finished[ %d ] = %lld\n" , i , finished[ i ] ) ;
    }
    **/
    dfs_up ( 1 , -1 , 0 ) ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        cout << 1LL * n * ( n + 1 ) / 2 - ans[ i ] << "\n" ;
    }
}

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