#include <bits/stdc++.h>
#include <map>

using namespace std;

vector<int> primes;
void getPrimes(int max)
{
    int i, j;
    primes.push_back(2);
    primes.push_back(3);
    primes.push_back(5);
    primes.push_back(7);
    for ( i = 11 ; i <= max ; i++  )    
    {
        bool isPrime = true;
        for ( j = 0 ; j < primes.size() ; j++ )
        {
            int pr = primes[j];
            if ( (i % pr) == 0 )
            {
                isPrime = false;
                break;
            }
            if ( pr*pr > i )
                break;
        }
        if ( isPrime )
        {
//            cout << "Prime " << i << endl;
            primes.push_back(i);
        }
    }
}

inline bool isPrime(int num)
{
    int idx1, idx2;
    idx1 = 0;
    idx2 = primes.size() - 1;
    if ( primes[idx1] == num || primes[idx2] == num )
        return true;
    while ( idx1+1 < idx2 )
    {
        int mid = (idx1 + idx2) / 2;
        int prime = primes[mid];
        
        if ( num == prime )
            return true;
        if ( num > prime )
            idx1 = mid;
        else 
            idx2 = mid;
    }
    if ( primes[idx1] == num || primes[idx2] == num )
        return true;
    else
        return false;
}

inline map<long,int> factorize(long num)
{
    map<long,int> ret;
    int idx = 0;
    while ( num > 1 && idx < primes.size() )
    {
        int p = primes[idx];
        if ( p*p > num )
            break;
        int count = 0;
        while ( (num%p) == 0 )
        {
            num = num / p;
            count++;
        }
        if ( count )
            ret[p] = count;
        idx++;
    }  
    if ( num > 1 )
    {
//        assert(isPrime(num));
        ret[num] = 1;
    }
    
    return ret;
}

long *getFactors(long value, int &count)
{
    map<long,int> f = factorize(value);
    
    list<long> l1, l2;
    list<long> *cur, *nxt;
    
    cur = &l1, nxt = &l2;

    cur->push_back(1);
    map<long,int>::iterator it;
    for ( it = f.begin() ; it != f.end() ; it++ )
    {
        long base = it->first;
        int power = it->second;
        
//        cout << base << "^" << power << endl;
        int i;
        nxt->clear();
        while ( cur->size() > 0 )
        {
            long num = 1;            
            long val = cur->front();
            cur->pop_front();
            for ( i = 0 ; i <= power ; i++ )
            {
                nxt->push_back(val*num);
                num = num * base;
            }            
        }       
        list<long> *temp;
        temp = cur;
        cur = nxt;
        nxt = temp;
    }
    
    long *ret = new long[cur->size()];
    long *entry = ret;
    {
        list<long>::iterator it;
        for ( it = cur->begin() ; it != cur->end() ; it++, entry++ )
            *entry = *it;
    }
    count = cur->size();
    
    return ret;
}

map<long,long> values;

long getValue(long value)
{
    if ( values[value] > 0 )
        return values[value];
    int cnt;
    long *f = getFactors(value, cnt);
    
    long max = value + 1;
    for ( int i = 0 ; i < cnt ; i++ )    
    {
        long count = f[i];
        if ( count == 1 || count == value )
            continue;
        long div = value / count;
        long num = 1 + count * getValue(div);
        
        if ( max < num )
            max = num;        
    }
    
    values[value] = max;
    
    return max;
}

long longestSequence(vector <long> a) {
    int i;
    long sum = 0;
    
    for ( i = 0 ; i < a.size() ; i++ )
    {
        long val = a[i];
        
        sum += getValue(val);
    }
    return sum;
}


int main() {
    long n, i;
    
    getPrimes(1000000);
    cin >> n;
//    cout << "Prime " << primes.size() << endl;
    #if 0
    list<long> f = getFactors(1000000000000);
    list<long>::iterator it;
    for ( it = f.begin() ; it != f.end() ; it++ )
        cout << *it << " ";
    cout << endl;
    #endif
    values[1] = 1;
    for ( i = 0 ; i < primes.size() ; i++ )
        values[primes[i]] = primes[i] + 1;

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