#include <stdio.h>
#include <stdbool.h>
#include <assert.h>

typedef long long int LLI;

/*
#define NAIVE_N 10000
static LLI _f_naive[NAIVE_N] = {}, _turn[NAIVE_N] = {};
static void fill_f_naive() {
    _f_naive[0] = 0, _f_naive[1] = 1;
    for(int i = 2 ; i < NAIVE_N ; ++i) {
        for(int j = 1 ; j <= i ; ++j) if(i % j == 0) {
            const LLI ff = 1 + j * _f_naive[i/j];
            if(ff > _f_naive[i]) { _f_naive[i] = ff, _turn[i] = j; }
        }
    }
}
static void print_turns_naive(LLI n) {
    const LLI f1 = _f_naive[n], t = _turn[n], n2 = n / t, f2 = _f_naive[n2];
    printf("%lld[%lld] -> [%lld] -> %lld[%lld]\n", n, f1, t, n2, f2);
    if(n2 > 1) print_turns_naive(n2);
}
*/

#define MAX_PRIME 999983
#define PRIME_COUNT 78498
static bool _is_composite[MAX_PRIME/2+1] = {}; // 2*i+1
static LLI _prime[PRIME_COUNT];
static void generate_primes() {
    // sieve
    _is_composite[0] = true;
    for(LLI i = 1, j = 3 ; j*j <= MAX_PRIME ; ++i, j+= 2) {
        if(_is_composite[i]) continue;
        for(LLI jj = j*j, ii = (jj-1)/2 ; jj <= MAX_PRIME ; jj += 2*j, ii += j)
            _is_composite[ii] = true;
    }

    // collect primes
    _prime[0] = 2;
    for(LLI i = 0, n = (MAX_PRIME-1)/2, pi = 1 ; i <= n ; ++i) {
        if(_is_composite[i]) continue;
        assert(pi < PRIME_COUNT); _prime[pi++] = 2*i+1;
    }
}

static inline LLI calc_f(LLI n) {
    LLI ret = 1;
    for(int i = 0 ; i < PRIME_COUNT ; ++i) {
        const LLI p = _prime[i]; if(p*p > n) break;
        while(n % p == 0)
            ret = p*ret + 1, n /= p;
    }
    if(n > 1)
        ret = n*ret + 1, n = 1;
    return ret;
}

int main() {
    generate_primes();
    int N; scanf("%d\n", &N);
    LLI ans = 0; for(int i = 0 ; i < N ; ++i) {
        LLI ai; scanf("%lld ", &ai); ans += calc_f(ai);
    }
    printf("%lld\n", ans);

/*
    fill_f_naive();
    for(int i = 1 ; i < NAIVE_N ; ++i)
        assert(calc_f(i) == _f_naive[i]);
*/

    return 0;
}