#!/bin/python

import math
import sys

primes = []
known_values = dict()

def divisorGenerator(n):
    large_divisors = []
    for i in xrange(2, int(math.sqrt(n) + 1)):
        if n % i == 0:
            yield i
    for divisor in reversed(large_divisors):
        yield divisor

def factorize(n):
    def isPrime(n):
        return not [x for x in xrange(2,int(math.sqrt(n))+1)
                    if n%x == 0]
    global primes
    candidates = xrange(2,n+1)
    candidate = 2
    while not primes and candidate in candidates:
        if n%candidate == 0 and isPrime(candidate):
            primes = primes + [candidate] + factorize(n/candidate)
        candidate += 1            
    return shrink(primes)

def shrink(n):
    n.sort()
    new_n = []
    if len(n) == 0:
        return new_n
    new_n.append(n[0])
    last_term = n[0]
    for i in range(1, len(n)):
        curr = n[i]
        if curr == last_term:
            new_n[len(new_n) - 1] *= curr
        else:
            new_n.append(curr)
            last_term = curr
    if len(new_n) == len(n):
        return new_n
    return shrink(new_n)

def is_power2(num):
	return num != 0 and ((num & (num - 1)) == 0)

def longestSequence(a):
    sum = 0
    for a_i in a:
        if a_i == 1:
            sum += 1
            continue
        sum += longestSequenceOne(a_i, None)
    return sum

def longestSequenceOne(a,b):
    global known_values
    if a in known_values:
        return known_values[a]
    global primes
    primes = []
    #factors = factorize(a)
    factors = list(divisorGenerator(a))
    max = 0
    if len(factors) == 0:
        answer = a + 1
        known_values[a] = answer
        return answer
    for factor in factors:
        oner = factor
        twoer = a / factor        
        answer1 = 1 + oner * longestSequenceOne(twoer, None)
        if answer1 > max:
            max = answer1
        if oner != twoer:
            answer2 = 1 + twoer * longestSequenceOne(oner, None)
            if answer2 > max:
                max = answer2            
    known_values[a] = max
    return max

if __name__ == "__main__":
    n = int(raw_input().strip())
    a = map(long, raw_input().strip().split(' '))
    result = longestSequence(a)
    print result