import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    static long longestSequence(long[] a) {
        //  Return the length of the longest possible sequence of moves.
        long[] factors;
        long low;
        long high; 
        
        long sumSequence = 0;
        
        for(int i=0; i<a.length; i++) {
            long val = a[i];
            sumSequence += longestSequence(val);
        }
        return sumSequence;
    }
    
    static long longestSequence(long val) {
        if(val == 1)
            return 1;
        else if(val == 0)
            return 0;
        
        long[] factors = findFactors(val);
        long parts = 1;
        long sequence = 1;
        for(int i=factors.length-1; i>=0; i--) {
            parts *= factors[i];
            sequence += parts;
        }
        
        return sequence;
    }
    
    static long[] findDivisors(long val) {
        LinkedList<Long> divisors = new LinkedList<Long>();
        long low = 2; 
        long high = val/2 ;
        
        while(low <= high && low <= Math.sqrt(val)) {
            if(val % low == 0) {
                divisors.add(low);
                high = val / low;
                
                if(val % high == 0 && low != high)
                    divisors.add(high);
            }
            
            low++;
        }
        divisors.add(val);
        
        long divisors_arr[] = new long[divisors.size()];
        
        ListIterator<Long> it = divisors.listIterator();
        int i=0;
        while(it.hasNext()){
            divisors_arr[i++] = it.next();
        }
        Arrays.sort(divisors_arr);
        return divisors_arr;
    }
    
    static long[] findFactors(long val) {
        long[] divisors = findDivisors(val);
        boolean[] divisorFlag = new boolean[divisors.length];
        Arrays.fill(divisorFlag, true);
        
        LinkedList<Long> factors = new LinkedList<Long>();
        
        ListIterator<Long> it;
        
        for(int i=0; i<divisors.length; i++) {
            long divisor = divisors[i];
            it = factors.listIterator();
            while(it.hasNext()){
                if(divisor % it.next() == 0)
                    divisorFlag[i] = false;
            }
            
            if(divisorFlag[i]) {
                factors.add(divisor);
                // look for multiples
                long divisorExp = divisor*divisor;
                while(val % divisorExp == 0) {
                    factors.add(divisor);
                    divisorExp *= divisor;
                }
            }
        }
        
        it = factors.listIterator();
        long[] factors_arr = new long[factors.size()];
        int i=0;
        while(it.hasNext()) {
            factors_arr[i++] = it.next();
        }
        
        Arrays.sort(factors_arr);
        return factors_arr;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long[] a = new long[n];
        for(int a_i = 0; a_i < n; a_i++){
            a[a_i] = in.nextLong();
        }
        long result = longestSequence(a);
        System.out.println(result);
        in.close();
    }
}