#include <bits/stdc++.h>

using namespace std;

#define MAX_PRIME 1000000

int primes[MAX_PRIME];
int num_primes = 0;

void init_primes() {
    int is_prime[MAX_PRIME + 1];
    
    is_prime[0] = 0;
    is_prime[1] = 0;
    
    for (int i = 2; i < MAX_PRIME; i++) {
        is_prime[i] = 1;
    }
    
    int max_factor = (int) sqrt(MAX_PRIME);
    
    for (int i = 2; i < max_factor + 1; i++) {
        for (int j = i * i; j < MAX_PRIME + 1; j += i) {
            is_prime[j] = 0;
        }
    }
    
    for (int i = 0; i < MAX_PRIME + 1; i++) {
        if (is_prime[i]) {
            primes[num_primes] = i;
            num_primes++;
        }
    }
}

long longestSequence(vector <long> a) {
    //  Return the length of the longest possible sequence of moves.
    
    long length = a.size();
    
    int prime_factors[64];
    int multiplicity[64];
    int pf_len = 0;
    int m_len = 0;
    
    long sum = 0;
    
    for (int k = 0; k < length; k++) {
        pf_len = 0;
        m_len = 0;
        
        long bar_size = a[k];

        if (bar_size < 2) {
            sum += 1;
            continue;
        }
        
        for (int i = 0; primes[i] < bar_size + 1 && i < num_primes; i++) {
            int m = 0;
            long size = bar_size;
            
            while (0 == size % primes[i] && size > 0) {
                m++;
                size = size / primes[i];
            }
            
            if (m > 0) {
                multiplicity[m_len++] = m;
                prime_factors[pf_len++] = primes[i];
            }
        }
        
        long num_chunks = 1;
        sum += 1;
        for (int j = pf_len - 1; j >= 0; j--) {
            int current_pf = prime_factors[j];
            for (int i = multiplicity[j]; i > 0; i--) {
                sum += num_chunks * current_pf;
                num_chunks *= current_pf;
            }
        }
    }
    
    return sum;
}

int main() {
    int n;
    cin >> n;
    vector<long> a(n);
    for(int a_i = 0; a_i < n; a_i++){
       cin >> a[a_i];
    }
    
    init_primes();
    long result = longestSequence(a);
    cout << result << endl;
    return 0;
}