#include <bits/stdc++.h>
#define ll long long int

using namespace std;

bool visit[1000006];
long long least_prime[1000006];
long long large_prime[1001],large_prime_small_range[1000003];

bool prime[10000006];

bool isPrime(long long int n)
{
  
    if (n <= 1)  return false;
    if (n <= 3)  return true;
 
    if (n%2 == 0 || n%3 == 0) return false;
 
    for (long long int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
 
    return true;
}



void LeastPrimeFactor(){
	long long tot=1000003;
	least_prime[1]=1;
	for (ll i = 2; i <tot; i += 2)	least_prime[i] = 2;
	for (ll i = 3; i < tot; i += 2){
		if (!visit[i]){
			least_prime[i] = i;
			for (ll j = i; (j*i) < tot; j += 2){
				if (!visit[j*i])
				{
					visit[j*i] = true;
					least_prime[j*i] = i;
				}
			}
		}
	}
}

void sieve()
{
    memset(prime,true,sizeof(prime));
    prime[0]=prime[1]=false;
    
    for(ll i=2;i*i<=1000006;i++)
    {
        if(prime[i])
        {
            for(ll j=i*2;j<=1000006;j+=i)
            {
                prime[j]=false;
            }
        }
    }
}

void solve(long long ar[],int n)
{
    long long maxm;
    for(int i = 0;i<n;i++)
    {
        maxm=0;
        for(ll j =1;j<=sqrt(ar[i]);j++)
        {
            if(ar[i]%j==0)
            {
                if(ar[i]/j==j)
                {
                    if(prime[j])
                        maxm=max(maxm,j);
                }
                else
                {
                    if(prime[j])
                        maxm=max(maxm,j);
                    
                        if(ar[i]/j < 1000005)
                        {
                            if(prime[ar[i]/j])
                                maxm=max(maxm,ar[i]/j);
                        }
                        else if(isPrime(ar[i]/j))
                            maxm=max(maxm,ar[i]/j);
                }
            }
        }
        
        large_prime[i]=maxm;
       
    }
    large_prime_small_range[1]=1;
    for(int i=2;i<=1000002;i++)
    {
        if(prime[i])
            large_prime_small_range[i]=i;
        else
        {
            long long a = least_prime[i];
            long long num=i;
            
            maxm=0;
            
            while(num!=1)
            {
                a=least_prime[num];
                maxm=max(maxm,a);
                num=num/a;
            }
            large_prime_small_range[i]=maxm;
        }
    }
}

int main() {  
    
    sieve();
    LeastPrimeFactor();
    
    long long k,sum=0,ans=0,maxm=0;
    
    int n;
    cin >> n;
  
    long long ar[n+4];
    for (int i = 0; i < n; i++) {
        cin >> ar[i];
    }
    
    solve(ar,n);
    
    for(int i=0;i<n;i++)
    {
        long long p =ar[i];
        
        long long d = p;
        long long pr = large_prime[i];
        
        ans=0;
        k=1;
        
        while(d!=1)
        {
            d=d/pr;
            ans+=(k*pr);
            k=k*pr;
            
            if(d>1000001)
            {
            	 maxm=0;
		        for(ll j =1;j<=sqrt(d);j++)
		        {
		            if(d%j==0)
		            {
		                if(d/j==j)
		                {
		                    if(prime[j])
		                        maxm=max(maxm,j);
		                }
		                else
		                {
		                    if(prime[j])
		                        maxm=max(maxm,j);
		                    
		                        if(d/j < 1000005)
		                        {
		                            if(prime[d/j])
		                                maxm=max(maxm,d/j);
		                        }
		                        else if(isPrime(d/j))
		                            maxm=max(maxm,d/j);
		                }
		            }
		        }
		        
		        pr=maxm;
			}
			else
            pr=large_prime_small_range[d];
        }
        
        ans++;
        sum+=ans;
    }
    
    cout<<sum;
  
      
 
    return 0;
}