import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.SortedSet;
import java.util.Iterator;
import java.util.Set;
import java.util.HashMap;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Maxim Paliy
 */
public class Solution {

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputParser in = new InputParser(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        BreakingSticks solver = new BreakingSticks();
        solver.solve(1, in, out);
        out.close();
    }

    static class BreakingSticks {

        Map<Long, Long> known = new HashMap<>();
        SortedSet<Long> primes = new TreeSet<>();

        public void solve(int testNumber, InputParser in, PrintWriter out) throws Exception {
            long start = System.currentTimeMillis();
            findPrimes(1000000000000L);
            long primeTime = System.currentTimeMillis() - start;
            known.put(1L, 1L);
            known.put(2L, 3L);
            known.put(3L, 4L);
            int n = in.readInt();
            long totalMoves = 0L;
            long[] arr = in.readArrayOfLongs(n);
            for (int i = 0; i < n; i++) {
                totalMoves += getMoves(arr[i]);
            }
            out.println(totalMoves);
        }

        private void findPrimes(long i) {
            int limit = (int) Math.floor(Math.sqrt(i));
            boolean[] isPrime = new boolean[limit];
            Arrays.fill(isPrime, true);
            for (int j = 2; j <= limit; j++) {
                int idx = j;
                while ((idx += j) < limit) {
                    isPrime[idx] = false;
                }
            }
            for (int j = 2; j < isPrime.length; j++) {
                if (isPrime[j]) {
                    primes.add((long) j);
                }
            }
        }

        private long getMoves(long i) {
            if (known.containsKey(i)) {
                return known.get(i);
            }
            long moves = i + 1;
            Set<Long> divisors = getDivisors(i);

            for (Long divisor : divisors) {
                if ((divisor != 1L) && (divisor != i)) {
                    moves = Math.max(moves, getMoves(divisor) * (i / divisor) + 1);
                    moves = Math.max(moves, getMoves(i / divisor) * divisor + 1);
                }
            }
        /*for (long a = 2L; a <= Math.sqrt(i); a++) {
            if (i % a == 0) {
                moves = Math.max(moves, getMoves(a) * (i / a) + 1);
                moves = Math.max(moves, getMoves(i / a) * a + 1);
            }
        }*/
            known.put(i, moves);
            return moves;
        }

        private Set<Long> getDivisors(long i) {
            Iterator<Long> iterator = primes.iterator();
            Map<Long, Integer> primeFactors = new HashMap<>();
            long prime;
            while (iterator.hasNext() && ((prime = iterator.next()) <= Math.sqrt(i))) {
                int factor = 0;
                long primeValue = prime;
                while (i % prime == 0) {
                    prime *= primeValue;
                    factor++;
                }
                if (factor > 0) {
                    primeFactors.put(primeValue, factor);
                }
            }
            Set<Long> result = new HashSet<>();
            result.add(1L);
            for (Map.Entry<Long, Integer> primeFactor : primeFactors.entrySet()) {
                Set<Long> toAdd = new HashSet<>();
                for (Long aLong : result) {
                    int factor = 0;
                    long possibleDivisor = aLong * primeFactor.getKey();
                    while ((factor < primeFactor.getValue()) && (i % possibleDivisor == 0)) {
                        toAdd.add(possibleDivisor);
                        possibleDivisor *= primeFactor.getKey();
                    }
                }
                result.addAll(toAdd);
            }
            return result;
        }

    }

    static class InputParser {

        BufferedReader bufferedReader;

        public InputParser(Class klazz, int caseNumber) throws Exception {
            this("src/main/cases/" + klazz.getSimpleName() + "/" + caseNumber);
        }

        public InputParser() {
            this(System.in);
        }

        public InputParser(String fileName) throws Exception {
            bufferedReader = new BufferedReader(new FileReader(fileName));
        }

        public InputParser(InputStream in) {
            bufferedReader = new BufferedReader(new InputStreamReader(in));
        }

        public long[] readArrayOfLongs(int size) throws Exception {
            long[] result = new long[size];
            String line = bufferedReader.readLine();
            int lastSpacePos = 0;
            for (int j = 0; j < size; j++) {
                int spacePos = line.indexOf(' ', lastSpacePos);
                if (spacePos < 0) {
                    spacePos = line.length();
                }
                long value = Long.parseLong(line.substring(lastSpacePos, spacePos));
                result[j] = value;
                lastSpacePos = spacePos + 1;
            }
            return result;
        }

        public int readInt() throws Exception {
            return Integer.parseInt(bufferedReader.readLine());
        }

    }
}