package main
import "fmt"
import "io/ioutil"
import "math"
import "os"

func main() {
	primes := Primes(1e6)
	N := ScanInt(1, 100)
	NewLine()
	sum := 0
	div := make([]int, 50)
	for k := 0; k < N; k++ {
		A := ScanInt(1, 1e12)
		x := A
		div = div[:0]
		for _, p := range primes {
			if p * p > x {
				break
			}
			for x % p == 0 {
				div = append(div, p)
				x /= p
			}
		}
		if x > 1 {
			div = append(div, x)
		}
		x = A
		for k := len(div) - 1; k >= 0; k-- {
			sum += A / x
			x /= div[k]
		}
		sum += A
	}
	fmt.Println(sum)
}

func Primes(limit int) []int {
	if limit < 2 {
		return nil
	}
	list := []int{ 2 }
	comp := make([]bool, limit / 2 - 1)
	for n, c := range comp {
		if !c {
			p := 2 * n + 3
			list = append(list, p)
			if limit / p >= p {
				for k := (p * p - 3) / 2; k < len(comp); k += p {
					comp[k] = true
				}
			}
		}
	}
	return list
}

func NewLine() {
	if CheckInput {
		for n, b := range RemainingInput {
			if b != ' ' && b != '\t' && b != '\r' {
				Assert(b == '\n')
				RemainingInput = RemainingInput[n+1:]
				return
			}
		}
		Assert(false)
	}
}

func ScanInt(low, high int) int {
	return int(ScanInt64(int64(low), int64(high)))
}

func Assert(condition bool) {
	if !condition {
		panic("assertion failed")
	}
}

var RemainingInput []byte

func init() {
	var e error
	RemainingInput, e = ioutil.ReadAll(os.Stdin)
	if e != nil {
		panic(e)
	}
}

func ScanInt64(low, high int64) int64 {
	x := Btoi(ScanToken())
	Assert(low <= x && x <= high || !CheckInput)
	return x
}

func Btoi(s []byte) int64 {
	if s[0] == '-' {
		x := Btou(s[1:])
		Assert(x <= - math.MinInt64)
		return - int64(x)
	} else {
		x := Btou(s)
		Assert(x <= math.MaxInt64)
		return int64(x)
	}
}

var CheckInput = true

func ScanToken() []byte {
	for n, b := range RemainingInput {
		if b == ' ' || b == '\t' || b == '\r' {
			continue
		}
		if b == '\n' {
			Assert(!CheckInput)
			continue
		}
		RemainingInput = RemainingInput[n:]
		break
	}
	Assert(len(RemainingInput) > 0)
	n := 1
	for ; n < len(RemainingInput); n++ {
		b := RemainingInput[n]
		if b == ' ' || b == '\t' || b == '\r' || b == '\n' {
			break
		}
	}
	token := RemainingInput[:n]
	RemainingInput = RemainingInput[n:]
	return token
}

func Btou(s []byte) uint64 {
	Assert(len(s) > 0)
	var x uint64
	for _, d := range s {
		Assert('0' <= d && d <= '9')
		d -= '0'
		if x >= math.MaxUint64 / 10 {
			Assert(x == math.MaxUint64 / 10 && d <= math.MaxUint64 % 10)
		}
		x = x * 10 + uint64(d)
	}
	return x
}