#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <limits>

std::vector<uint64_t> GetPrimesUpTo(uint64_t n)
{
    std::vector<int> is_prime(n / 32 + 1, 0xFFFFFFFF);
    std::vector<uint64_t> primes;
    for (int ii = 2; ii <= n; ++ii)
    {
        if ((is_prime[ii / 32] & (1 << (ii % 32))) == 0) continue;
        
        primes.push_back(ii);
        
        for (int jj = ii * ii; jj <= n; jj += ii)
        {
            is_prime[jj / 32] &= ~(1 << (jj % 32));
        }
    }
    return primes;
}

uint64_t LongestMoveSequence(uint64_t length, const std::vector<uint64_t> &primes)
{
    uint64_t num_moves{ length };
    
    // Find prime factorization of length
    int primes_index{ 0 };
    auto prime = primes[primes_index];
    while (length > 1)
    {
        if ((length % prime) == 0)
        {
            length /= prime;
            num_moves += length;
        }
        else
        {
            prime = primes[++primes_index];
            
            // If we have checked all primes up to sqrt(length) and length is still not 1, length is a prime number
            if (primes_index == primes.size())
            {
                num_moves += 1;
                break;
            }
        }
    }
    
    return num_moves;
}

int main() {  
    int n{0};
    std::cin >> n;
  
    std::vector<uint64_t> lengths(n);
    for (int i = 0; i < n; i++) {
        std::cin >> lengths[i];
    }
  
    // We only need primes up to 10^6 to calculate factorization of numbers up to 10^12
    const auto primes = GetPrimesUpTo(1'000'000);
    uint64_t sequences_sum{0};
    for (auto length : lengths)
    {
        sequences_sum += LongestMoveSequence(length, primes);
    }
    
    std::cout << sequences_sum << std::endl;
 
    return 0;
}