#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cstring>
#include <utility>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_map>
using namespace std;

#define LL   long long
#define ld   long double
#define pii  pair<int,int>
#define pLL  pair<LL,LL>
#define vint vector<int>
#define vLL  vector<LL>
#define vpii vector<pii>

#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(),(x).end()
#define F first
#define S second
#define MP make_pair
#define PB push_back

#define Si(x) scanf("%d",&(x));
#define Sii(x,y) scanf("%d %d",&(x),&(y));
#define Siii(x,y,z) scanf("%d %d %d",&(x),&(y),&(z));
#define Siiii(x,y,z,w) scanf("%d %d %d %d",&(x),&(y),&(z),&(w));
#define Siiiii(x,y,z,w,a) scanf("%d %d %d %d %d",&(x),&(y),&(z),&(w),&(a));
#define Siiiiii(x,y,z,w,a,b) scanf("%d %d %d %d %d %d",&(x),&(y),&(z),&(w),&(a),&(b));
#define SL(x) scanf("%lld",&(x));
#define SLL(x,y) scanf("%lld %lld",&(x),&(y));
#define SLLL(x,y,z) scanf("%lld %lld %lld",&(x),&(y),&(z));
#define SLLLL(x,y,z,w) scanf("%lld %lld %lld %lld",&(x),&(y),&(z),&(w));
#define SLLLLL(x,y,z,w,a) scanf("%lld %lld %lld %lld %lld",&(x),&(y),&(z),&(w),&(a));
#define SLLLLLL(x,y,z,w,a,b) scanf("%lld %lld %lld %lld %lld %lld",&(x),&(y),&(z),&(w),&(a),&(b));

#define Pi(x) printf("%d\n",(x));
#define Pii(x,y) printf("%d %d\n",(x),(y));
#define Piii(x,y,z) printf("%d %d %d\n",(x),(y),(z));
#define Piiii(x,y,z,w) printf("%d %d %d %d\n",(x),(y),(z),(w));
#define Piiiii(a,b,c,d,e) printf("%d %d %d %d %d\n",(a),(b),(c),(d),(e));
#define Piiiiii(a,b,c,d,e,f) printf("%d %d %d %d %d %d\n",(a),(b),(c),(d),(e),(f));
#define PL(x) printf("%lld\n",(x)*1LL);
#define PLL(x,y) printf("%lld %lld\n",(x)*1LL,(y)*1LL);
#define PLLL(x,y,z) printf("%lld %lld %lld\n",(x)*1LL,(y)*1LL,(z)*1LL);
#define PLLLL(x,y,z,w) printf("%lld %lld %lld %lld\n",(x)*1LL,(y)*1LL,(z)*1LL,(w)*1LL);
#define PLLLLL(a,b,c,d,e) printf("%lld %lld %lld %lld %lld\n",(a),(b),(c),(d),(e));
#define PLLLLLL(a,b,c,d,e,f) printf("%lld %lld %lld %lld %lld %lld\n",(a),(b),(c),(d),(e),(f));

#define Pi1(x) printf("%d",  (x));
#define PL1(x) printf("%lld",(x));
#define Pspace putchar(' ');
#define Pendl  puts("");

#define MEM0(x) memset( (x), 0, sizeof( (x) ) )
#define MEM1(x) memset( (x),-1, sizeof( (x) ) )
#define REP1(i,n)  for (int i = 1; (n) >= i ; ++i)
#define REP0(i,n)  for (int i = 0; (n) >  i ; ++i)

int myRnd() {
    return abs(  ((rand()<<15) | rand()) );
}

int myRnd(int L,int R) {
    return abs(( (rand()<<15)|rand() ) ) % (R-L+1) + L;
}

void Parr(int *arr,int L,int R) {
    for (int i=L;R>=i;i++) {
        printf("%d%c",arr[i]," \n"[i==R]);
    }
}

void Pvec(vint v) {
    for (int i=0;SZ(v)>i;i++) {
        printf("%d%c",v[i]," \n"[i==SZ(v)-1]);
    }
}

void Sarr(LL *arr,int L,int R) {
    for (int i=L;R>=i;i++)
    {
        SL(arr[i]);
    }
}

#define SZ(x) ((int)(x).size())
const int MAX_N = 1e6 +6;
int prime[MAX_N];

void build() {
	prime[0] = prime[1] = 1;
	for (int i=2;MAX_N>i;i++) {
		if (prime[i] == 0) {
			prime[i]=i;
			for (long long j=i*1LL*i;MAX_N>j;j+=i) {
				prime[j] = i;
			}
		}
	}
}

vector<pii> get_prime_divisor(int x) {
	vector<pii> ret;
	while (x!=1) {
		pii tmp;
		tmp.first = prime[x];
		int cnt=0;
		int pp=prime[x];
		while (x%pp==0) {
			x/=pp;
			cnt++;
		}
		tmp.second = cnt;
		ret.emplace_back(tmp);
	}
	return ret;
}

vector<int> get_divisor(int x) {
	vector<pii> prime_divisor=get_prime_divisor(x);
	int sz=SZ(prime_divisor);
	queue<pii> que;
	que.push({1,0});
	vector<int> ret;
	while (!que.empty()) {
		pii p=que.front();
		que.pop();
		if (p.second == sz) {
			ret.emplace_back(p.first);
			continue;
		}
		int t=1;
		for (int i=0;prime_divisor[p.second].second>=i;i++) {
			que.push(make_pair(p.first*t,p.second+1));
			t*=prime_divisor[p.second].first;
		}
	}
	return ret;
}

const int N = 1e2 + 6;

LL a[N];

unordered_map<LL,LL> mp;

vLL factor;

LL solve(LL n)
{
    if(mp[n]) return mp[n];
    LL ret=1;
    if (n==1)
    {
        mp[n] = 1;
        return ret;
    }
    if (n < MAX_N)
    {
        vint rret= get_divisor(n);
        for (LL i:rret)
        {
            if (i==n) continue;
            ret = max(ret, (n/i)*solve(i) + 1);
        }
    }
    else
    {
        for (LL i:factor)
        {
            if (i==n) continue;
            if (n%i != 0) continue;
            ret = max(ret, (n/i)*solve(i) + 1);
        }
    }
    mp[n] = ret;
    return ret;
}

int main () {
    srand(time(NULL));
    build();
    int n;
    Si(n);
    Sarr(a,1,n);
    LL ans=0;
    REP1(i,n)
    {
        factor.clear();
        for (LL j=1;1000000>=j;j++)
        {
            if (a[i] % j == 0)
            {
                factor.push_back(j);
                factor.push_back(a[i]/j);
            }
        }
        ans += solve(a[i]);
    }
    PL(ans);
}