import sys


class DSU:
    def __init__(self, n):
        self.parent = [-1] * n

    def find(self, x):
        if self.parent[x] < 0:
            return x
        self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def merge(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return False
        if self.parent[x] > self.parent[y]:
            x, y = y, x
        self.parent[x] += self.parent[y]
        self.parent[y] = x
        return True

    def same(self, x, y):
        return self.find(x) == self.find(y)


M = 1010101
minfactor = [-1] * M


def factorize(n):
    res = []
    if n <= 1:
        return res
    while n > 1:
        p = minfactor[n]
        e = 0
        while n % p == 0:
            n //= p
            e += 1
        res.append((p, e))
    return res


isprime = [True] * M
isprime[0] = isprime[1] = False
for p in range(2, M):
    if isprime[p]:
        minfactor[p] = p
        for q in range(p * 2, M, p):
            isprime[q] = False
            if minfactor[q] == -1:
                minfactor[q] = p
n = int(sys.stdin.readline())
a_list = list(map(int, sys.stdin.read().split()))

edges = [[] for _ in range(M)]
ans = 0

for i, a in enumerate(a_list):
    for p, e in factorize(a):
        weight = p * e
        edges[weight].append((i, n + p))
        ans += weight

dsu = DSU(n + M)

for w in range(M - 1, -1, -1):
    for u, v in edges[w]:
        if not dsu.same(u, v):
            dsu.merge(u, v)
            ans -= w

print(ans)