import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Tourists
 * 
 * @author vanb
 */
public class tourists_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /** A list of the Attractions, indexed by their node number */
    public Attraction attractions[];
    
    /** A list of Attractions, indexed by their Euler path visit number. */
    public Attraction euler[];
    
    /** Position in the Euler path */
    public int count = 0;
    
    /** Segment Tree */
    public Attraction segtree[];
    
    /**
     * Capture information about an Attraction, which will be a node in a tree.
     * 
     * @author vanb
     */
    public class Attraction
    {
        /** Visitation number in Euler path in & out, and depth. */
        public int in, out, depth;
        
        /** Adjacent Attractions */
        public LinkedList<Attraction> neighbors = new LinkedList<Attraction>();
        
        /**
         * Build the parameters of a node, 
         * specifically Euler path in & out numbers, and depth.
         * 
         * @param depth Depth of this node
         * @param from The node we came from
         */
        public void build( int depth, Attraction from )
        {
            // Record depth, and increment depth for neighbors.
            this.depth = depth++;
            
            // Record this node's IN position in the Euler path
            // If this node has no neighbors, then it's also the OUT position
            euler[this.in = this.out = ++count] = this;
            
            // Visit neighbors, skipping the node we came from.
            for( Attraction neighbor : neighbors ) if( neighbor!=from )
            {
                //Visit neighbor
                neighbor.build( depth, this );
                
                // Put this node in the Euler path again
                // Remember this node's OUT position in the Euler path
                // (last one wins)
                euler[this.out = ++count] = this;
            }
        }
    }
    
    /**
     * Build the Segment Tree subtree rooted at a node.
     * 
     * @param node Root node of subtree
     * @param lo Lower bound of segment
     * @param hi Upper bound of segment
     * @return
     */
    public Attraction buildSegmentTree( int node, int lo, int hi )
    {
        if( lo==hi )
        {
            // If lo=hi, then we're at a leaf.
            segtree[node] = euler[lo];
        }
        else
        {
            // Build left and right subtrees
            int mid = (hi+lo)/2;
            Attraction left = buildSegmentTree( node+node, lo, mid );
            Attraction right = buildSegmentTree( node+node+1, mid+1, hi );
            
            // Pick the smaller of the two for this node
            segtree[node] = (left.depth<right.depth) ? left : right;
        }
        
        return segtree[node];
    }
    
    /**
     * Retrieve the node with the smallest depth within an interval of the Euler path.
     * 
     * @param node Node of the Segment Tree of the subtree we're examining
     * @param lo Lower bound of the segment for this node
     * @param hi Upper bound for the segment of this node
     * @param lower Lower endpoint of the interval of interest
     * @param upper Upper endpoint of the interval of interest
     * @return The Attraction with the smallest depth in the interval [lower,upper] of the Euler path
     */
    public Attraction retrieve( int node, int lo, int hi, int lower, int upper )
    {
        Attraction result = null;
        
        if( lower<=lo && hi<=upper )
        {
            // If this segment is entirely contained in the interval of interest,
            // then we don't have to go any farther.
            result = segtree[node];
        }
        else
        {
            // Our segment isn't small enough yet, we have to split it in 2.
            int mid = (lo+hi)/2;
            Attraction left = (mid>=lower) ? retrieve( node+node, lo, mid, lower, upper ) : null;
            Attraction right = (mid<upper) ? retrieve( node+node+1, mid+1, hi, lower, upper ) : null;
            
            // Pick the one that exists, and is smaller
            if( left==null ) result = right;
            else if( right==null ) result = left;
            else if( left.depth<right.depth ) result = left;
            else result = right;
        }
        
        return result;
    }
    
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        int n = sc.nextInt();
        
        // List of Attractions. The Attraction's numbers are 1-based.
        // Rather than convert them to 0-based, we'll just allocate
        // one more element than needed, and ignore element 0.
        attractions = new Attraction[n+1];
        
        // Every node appears twice in the Euler path - on the way in,
        // and on the way out. So, we'll need twice as many slots.
        euler = new Attraction[n+n+1];
        
        // We'll build a Segment Tree over the Euler Path. That's a Binary
        // Tree with the Euler Path as its leaves. So, we'll need twice as much
        // storage as the Euler path.
        segtree = new Attraction[8*n+1];
        
        // Build the Attractions list
        for( int i=1; i<=n; i++ ) attractions[i] = new Attraction();
        
        // Read in and record the edges
        for( int i=1; i<n; i++ )
        {
            int a = sc.nextInt();
            int b = sc.nextInt();
            attractions[a].neighbors.add( attractions[b] );
            attractions[b].neighbors.add( attractions[a] );
        }
        
        // Build all of the parameters.
        // Arbitrarily choose Attraction 1 as the root.
        attractions[1].build( 0, null );
        
        // Build the segment tree (node 1 is the root, the entire Euler path is the interval)
        buildSegmentTree( 1, 1, count );
        
        long total = 0L;
        
        // Go through all pairs x,y where y>x and y%x==0
        for( int x=1; x<=n; x++ ) for( int y=x+x; y<=n; y+=x )
        {
            // 'first' will be the node which comes earlier in the Euler path.
            // 'last' will (obviously) be the one that comes later in the Euler path.
            Attraction first, last;
            if( attractions[x].in<attractions[y].in )
            {
                first = attractions[x];
                last = attractions[y];
            }
            else
            {
                first = attractions[y];
                last = attractions[x];                
            }
                        
            if( first.out > last.out )
            {
                // In an Euler path, a node is an ancestor of
                // another node iff ancestor.in<descendant.in and ancestor.out>descendant.out.
                // That is, you hit the ancestor on the way into the subtree, 
                // then you hit the descendant, then you hit the ancestor again on the way out.
                // We already know that first.in<last.in. If first.out>last.out,
                // then last must be a direct descendant of first.
                // So the distance is the different in their depths, plus one for 
                // first itself.
                total += last.depth - first.depth + 1;
            }
            else
            {         
                // The lower bound of our interval in the Euler path is first.out, 
                // and the upper bound is last.in.
                Attraction ancestor = retrieve( 1, 1, count, first.out, last.in );
                
                // The path from first to last goes from first, up to ancestor, and then down to last.
                // For the total, we need the distance from first to ancestor (first.depth-ancestor.depth),
                // plus the distance from ancestor to last (last.depth-ancestor.depth),
                // plus one for the ancestor itself
                total += first.depth-ancestor.depth + last.depth-ancestor.depth + 1;
            }
        }
        
        ps.println( total );
    }
    
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
       new tourists_vanb().doit();        
    }   
}