import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;


				
					 
					public class Solution1 implements Runnable
					{
						static final int MAX = 1000000007;
						static class InputReader
						{
							private InputStream stream;
							private byte[] buf = new byte[1024];
							private int curChar;
							private int numChars;
							private SpaceCharFilter filter;
							private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
					
							public InputReader(InputStream stream)
							{
								this.stream = stream;
							}
							
							public int read()
							{
								if (numChars==-1) 
									throw new InputMismatchException();
								
								if (curChar >= numChars)
								{
									curChar = 0;
									try 
									{
										numChars = stream.read(buf);
									}
									catch (IOException e)
									{
										throw new InputMismatchException();
									}
									
									if(numChars <= 0)				
										return -1;
								}
								return buf[curChar++];
							}
						 
							public String nextLine()
							{
								String str = "";
					            try
					            {
					                str = br.readLine();
					            }
					            catch (IOException e)
					            {
					                e.printStackTrace();
					            }
					            return str;
							}
							public int nextInt()
							{
								int c = read();
								
								while(isSpaceChar(c)) 
									c = read();
								
								int sgn = 1;
								
								if (c == '-') 
								{
									sgn = -1;
									c = read();
								}
								
								int res = 0;
								do 
								{
									if(c<'0'||c>'9') 
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c)); 
								
								return res * sgn;
							}
							
							public long nextLong() 
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-') 
								{
									sgn = -1;
									c = read();
								}
								long res = 0;
								
								do 
								{
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								while (!isSpaceChar(c));
									return res * sgn;
							}
							
							public double nextDouble() 
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								int sgn = 1;
								if (c == '-') 
								{
									sgn = -1;
									c = read();
								}
								double res = 0;
								while (!isSpaceChar(c) && c != '.') 
								{
									if (c == 'e' || c == 'E')
										return res * Math.pow(10, nextInt());
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									res *= 10;
									res += c - '0';
									c = read();
								}
								if (c == '.') 
								{
									c = read();
									double m = 1;
									while (!isSpaceChar(c)) 
									{
										if (c == 'e' || c == 'E')
											return res * Math.pow(10, nextInt());
										if (c < '0' || c > '9')
											throw new InputMismatchException();
										m /= 10;
										res += (c - '0') * m;
										c = read();
									}
								}
								return res * sgn;
							}
							
							public String readString() 
							{
								int c = read();
								while (isSpaceChar(c))
									c = read();
								StringBuilder res = new StringBuilder();
								do 
								{
									res.appendCodePoint(c);
									c = read();
								} 
								while (!isSpaceChar(c));
								
								return res.toString();
							}
						 
							public boolean isSpaceChar(int c) 
							{
								if (filter != null)
									return filter.isSpaceChar(c);
								return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
							}
						 
							public String next() 
							{
								return readString();
							}
							
							public interface SpaceCharFilter 
							{
								public boolean isSpaceChar(int ch);
							}
						}
					 	
						public static void main(String args[]) throws Exception
						{
							new Thread(null, new Solution1(),"Solution1",1<<26).start();
						}
						long power(long x, long y)
						{
						    long res = 1;      // Initialize result
						 
						    x = x % MAX;  // Update x if it is more than or 
						                // equal to p
						 
						    while (y > 0)
						    {
						        // If y is odd, multiply x with result
						        if (y % 2 == 1)
						            res = (res*x) % MAX;
						 
						        // y must be even now
						        y = y>>1; // y = y/2
						        x = (x*x) % MAX;  
						    }
						    return res;
						}
						public void run()
						{
							InputReader sc= new InputReader(System.in);
							PrintWriter w= new PrintWriter(System.out);
							int n = sc.nextInt();
							long[] arr = new long[n];
							for(int i = 0;i < n;i++){
								arr[i] = sc.nextLong();
							}
							long result = longestSequence(arr);
							w.println(result);
							w.close();
						}
						long longestSequence(long[] a) {
					        //  Return the length of the longest possible sequence of moves.
							ArrayList<Integer> primes = new ArrayList();
							primes = sieve(1000006);
							long count = 0;
							for(int i = 0;i < a.length;i++){
								if(a[i] == 1){
									count++;
									continue;
								}
								count += a[i];
								while(true){
									if(isPrime(a[i])){
										count++;
										break;
									}
									for(int j = 0;j < primes.size();j++){
										if(a[i] % primes.get(j) == 0){
											count += a[i]/primes.get(j);
											a[i] = a[i]/primes.get(j);
											break;
										}
									}
								}
							}
							return count;
					    }
						ArrayList<Integer> sieve(int n){
							 boolean[] isPrime = new boolean[n+1];
						        for (int i = 2; i <= n; i++) {
						            isPrime[i] = true;
						        }

						        // mark non-primes <= n using Sieve of Eratosthenes
						        for (int factor = 2; factor*factor <= n; factor++) {

						            // if factor is prime, then mark multiples of factor as nonprime
						            // suffices to consider mutiples factor, factor+1, ...,  n/factor
						            if (isPrime[factor]) {
						                for (int j = factor; factor*j <= n; j++) {
						                    isPrime[factor*j] = false;
						                }
						            }
						        }

						        // count primes
						        ArrayList<Integer> arr=  new ArrayList();
						        for (int i = 2; i <= n; i++) {
						            if (isPrime[i]) arr.add(i);
						        }
						       return arr;
						}
					    boolean isPrime(long n)
					    {
					        // Corner cases
					        if (n <= 1)  return true;
					        if (n <= 3)  return true;
					     
					        // This is checked so that we can skip 
					        // middle five numbers in below loop
					        if (n%2 == 0 || n%3 == 0) return false;
					     
					        for (long i=5; i*i<=n; i=i+6)
					            if (n%i == 0 || n%(i+2) == 0)
					               return false;
					     
					        return true;
					    }
						static class Pair implements Comparable<Pair>{
							int a;
							int b;
							Pair(int a,int b)	{
								this.a = a;
								this.b = b;
							}
							public boolean equals(Object o)
							{
								Pair p = (Pair)o;
								return p.a==a && p.b==b;
							}
							public int compareTo(Pair p){
								if(p.b == this.b){
									return Integer.compare(this.a,p.a);
								}else{
									return Integer.compare(p.b,this.b);
								}
							}
							public int hashCode()
							{
								return new Long(a).hashCode()*31 + new Long(a).hashCode();
							}
						}
					}