#include <bits/stdc++.h>
using namespace std;

map<long long, long long> memo;// = {{1, 0}, {2, 1}};
map<long long, set<long long>> M;

set<long long> Factorize(long long n)
{
    set<long long> factors = {1, n};
    long long end = n;
    
    for(long long i=2; i<end; i++)
    {
        if(end % i == 0)
        {
            long long j = n/i;
            
            factors.insert(i);
            factors.insert(j);
            end = j;
        }
    }
    M[n] = factors;
    return factors;
}


long long Solve(long long n, int depth)
{
    long long ans = 0;
    
    if(memo.count(n)) return memo[n];
    
    if(n > 100)
    {
        //return 0;
        long long end = sqrt(n);
        
        for(long long i=2; i<=end; i++)
        {
            if(n % i == 0)
            {
                ans = (memo.count(n/i)) ? memo[n/i] : max(ans, Solve(n/i, depth+1));
                break;
                
                end = n/i;
            }
        }
        if(ans == 0) 
        {
            memo[n] = n+1;
            return n + 1;
        }
        memo[n] = ans + n;
        return ans + n;
    }
        
    vector<long long> dp(n+1, 0);
    //map<long long, long long> dp;
    dp[1] = 1;        
    
    set<long long> F = (M.count(n)) ? M[n] : Factorize(n);
    long long E = n;
         
    for(auto f : F)
    {
        //if(f >= E) break;
        long long i = f;
        long long end = i;
        
        E = n/i;     
        
        if(memo.count(i))
        {
            dp[i] = memo[i];                        
            continue;
        }               
        
        set<long long> factors = (M.count(i)) ? M[i] : Factorize(i);
        
        //cerr << i << "\n\t";
        
        for(auto it : factors)
        {           
            if(it >= end) break;
            //cerr << it << " ";
            
            long long x = i/it;

            dp[i] = max(dp[i], max((it*dp[x]) + 1, (x*dp[it]) + 1));
            end = x;                    
        }
        memo[i] = dp[i];
       // cerr << "\n";
    }
    //cerr << string(depth-1, '\t') << n << " | " << dp[n] << endl;
    memo[n] = dp[n];
    return dp[n];
}

vector<short> Add(vector<short> a, vector<short> b)
{
    vector<short> res;
    
    if(b.size() > a.size()) swap(a, b);
    
    short carry = 0;
    
    while(!a.empty())
    {
        int sum = a.back() + carry + ((!b.empty()) ? b.back() : 0);
        carry = sum / 10;                   
        sum %= 10;
        
        res.push_back(sum);
        
        a.pop_back();
        
        if(!b.empty()) b.pop_back();
    }
    while(carry)
    {
        res.push_back(carry);
        carry /= 10;
    }
    reverse(res.begin(), res.end());
    return res;
}

int main() 
{  
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    
    int n;
    cin >> n;
  
    vector <long long> A(n);
    //long long ans = 0;
    
    for (int i = 0; i < n; i++) 
    {
        cin >> A[i];
        
        //long long num = Solve(A[i], 1); 
        //ans += num;                
        
        //cerr << "\n------------\n";
        //cerr << A[i] << " | " << num << endl;
    }
    sort(A.rbegin(), A.rend());
    
    vector<short> ans = {0};
    
    //long long num = Solve(A.back(), 1);        
    
    for(auto it : A)
    {
        long long num = (memo.count(it)) ? memo[it] : Solve(it, 1);
        
        string s = to_string(num);
        
        vector<short> b;
        
        for(auto d : s)
        {
            b.push_back(d-'0');
        }
        cerr << it << " | " << num << endl;
        ans = Add(ans, b);
    }
    for(auto it : ans)
    {
        cout << it;
    }
    //cout << ans << endl;
   
    return 0;
}

/*
[1]: 1

[2]:
     1 
    
[3]: 
     
    


*/