#!/bin/python3

import sys
from functools import reduce
import copy

def factorGenerator(n):    
    return set(reduce(list.__add__,([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))

def divisorGen(n):
    factors = [x for x in factorGenerator(n)]
    factors[:2]
    divisors = set()
    matrix = []
    for _ in range(len(factors)):
        matrix.append([0] * len(factors))
    for i in range(len(factors)):
        divisors.add(factors[i])
        for j in range(i, len(factors)):
            matrix[i][j] = factors[i]
    l_prev = 0
    while l_prev != len(divisors):
        l_prev = len(divisors)
        for i in range(len(factors)):
            divisors.add(factors[i])
            for j in range(i, len(factors)):
                prod = matrix[i][j] * factors[j]
                if n % prod == 0:
                    divisors.add(prod)
                if prod < n:
                    matrix[i][j] = prod
    divisors.remove(1)
    return divisors

def numOfActions(length): 
    if length in max_number_of_moves:
        return max_number_of_moves[length]
    
    max_actions = 0
    
    for d in divisorGen(length):
        actions = 1
        actions += d * numOfActions(int(length / d))
        max_actions = max(max_actions, actions)
    max_number_of_moves[length] = max_actions
    return max_actions

def longestSequence(a):
    for length in a:
        if length in max_number_of_moves:
            continue
        numOfActions(length)
        
    s = 0
    for length in a:
        s += max_number_of_moves[length]
        
    return s

if __name__ == "__main__":
    max_number_of_moves = {1: 1}
    n = int(input().strip())
    a = list(map(int, input().strip().split(' ')))
    result = longestSequence(a)
    print(result)