#include <cstdio>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <bitset>
#include <stack>
#include <string>
#include <queue>
#include <list>
#include <iomanip>
#include <limits>
#include <typeinfo>
#include <functional>
#include <numeric>
#include <complex>

using namespace std;

bool isPrime(int num)
{
    if(num == 2 || num == 3)
        return 1 ;
    if(num % 6 != 1 && num % 6 != 5)
        return 0 ;
    int tmp = sqrt(num);
    for(int i = 5; i <= tmp; i += 6 )
        if(num % i == 0 || num % (i + 2) == 0)
            return 0 ;
    return 1 ;
}

int64_t prime[1000000];
bool isprime[1000000];

void getPrime(int64_t x)
{
    for (int64_t i = 1; i < x; i += 2) {
        isprime[i] = 1;
        isprime[i - 1] = 0;
    }

    prime[prime[0] = 1] = 2;
    for (int64_t i = 3; ; i += 2) {
        if(isprime[i]) {
            int64_t j = i*i, k = i+i;

            if(j >= x) break;

            while(j < x ) {
                isprime[j] = 0;
                j += k;
            }
        }
    }
    for (int64_t i = 3; i < x; i += 2) {
        if(isprime[i]) {
            prime[++prime[0]] = i;
        }
    }
}

int64_t p[34380], cnt[34380];

void getPrimeDivisor(int64_t x)
{
    p[0] = cnt[0] = 0;
    int64_t t;
    for (int64_t i = 1; prime[i]*prime[i] <= x  && i <= prime[0]; ++i) {
        t = 0;
        while (x%prime[i] == 0) {
            ++t;
            x /= prime[i];
            p[++p[0]] = prime[i];
        }
        if (t) {
            cnt[++cnt[0]] = t;
        }
    }
    if (x > 1) {
        p[++p[0]] = x;
        cnt[++cnt[0]] = 1;
    }
};

map<int64_t, int64_t> DP;
int64_t _calc(int64_t stick)
{
    if (DP.find(stick) != DP.end()) {
        return DP[stick];
    }

    if (isPrime(stick)) {
        DP[stick] = stick + 1;
    } else {
        int64_t sum = 1;
        int64_t current = 1;
        getPrimeDivisor(stick);
        for (int64_t i = p[0]; i > 0; i--) {
            if (DP.find(stick/current) != DP.end()) {
                DP[stick] = sum + current * DP[stick/current] - current;
                break;
            }
            current = current*p[i];
            sum += current;
            DP[current] = sum;
        }
    }
    return DP[stick];
}

int64_t calc(vector<int64_t> sticks)
{
    int64_t res = 0;
    for (auto stick : sticks) {
        res += _calc(stick);
    }
    return res;
}

int main()
{
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    vector<int64_t> sticks(n);
    for (int i = 0; i < n; i++) {
        cin >> sticks[i];
    }

    DP[1] = 1;
    DP[2] = 3;
    DP[3] = 4;
    DP[4] = 7;
    DP[5] = 6;

    getPrime(1000000);

    int64_t res = calc(sticks);
    cout << res << endl;
    return 0;
}