package main

import (
	"fmt"
	"io"
	"os"
)

const MOD = 1000000007

func main() {
	b, err := io.ReadAll(os.Stdin)
	if err != nil {
		return
	}

	idx := 0
	readInt := func() int32 {
		for idx < len(b) && (b[idx] < '0' || b[idx] > '9') {
			idx++
		}
		if idx >= len(b) {
			return 0
		}
		var res int32 = 0
		for idx < len(b) && b[idx] >= '0' && b[idx] <= '9' {
			res = res*10 + int32(b[idx]-'0')
			idx++
		}
		return res
	}

	n := int(readInt())
	if n == 0 {
		return
	}

	var MAX int32 = 0
	A := make([]int32, n)
	for i := 0; i < n; i++ {
		A[i] = readInt()
		if A[i] > MAX {
			MAX = A[i]
		}
	}
	MAX++

	min_prime := make([]int32, MAX)
	var primes []int32
	for i := int32(2); i < MAX; i++ {
		if min_prime[i] == 0 {
			min_prime[i] = i
			primes = append(primes, i)
		}
		for _, p := range primes {
			if p > min_prime[i] || i*p >= MAX {
				break
			}
			min_prime[i*p] = p
		}
	}

	cnt := make([]int32, MAX)
	for i := 0; i < n; i++ {
		cnt[A[i]]++
	}

	for _, p := range primes {
		for j := (MAX - 1) / p; j >= 1; j-- {
			cnt[j] += cnt[j*p]
		}
	}

	p2 := make([]int32, n+1)
	p2[0] = 1
	for i := 1; i <= n; i++ {
		p2[i] = p2[i-1] * 2
		if p2[i] >= MOD {
			p2[i] -= MOD
		}
	}

	C := make([]int32, MAX)
	for i := int32(1); i < MAX; i++ {
		C[i] = p2[cnt[i]] - 1
		if C[i] < 0 {
			C[i] += MOD
		}
	}

	for _, p := range primes {
		for j := int32(1); j <= (MAX-1)/p; j++ {
			C[j] -= C[j*p]
			if C[j] < 0 {
				C[j] += MOD
			}
		}
	}

	cached_P := make([]int32, MAX)
	for i := int32(0); i < MAX; i++ {
		cached_P[i] = -1
	}

	ans := int64(0)
	for g := int32(2); g < MAX; g++ {
		if C[g] > 0 {
			r := int32(1)
			x := g
			for x > 1 {
				pr := min_prime[x]
				r *= pr
				for x%pr == 0 {
					x /= pr
				}
			}

			if cached_P[r] == -1 {
				p_factors := make([]int32, 0, 8)
				temp := r
				for temp > 1 {
					pr := min_prime[temp]
					p_factors = append(p_factors, pr)
					for temp%pr == 0 {
						temp /= pr
					}
				}

				sum := int32(0)
				n_p := len(p_factors)
				for mask := 0; mask < (1<<n_p); mask++ {
					d := int32(1)
					mu := 1
					for i := 0; i < n_p; i++ {
						if (mask & (1 << i)) != 0 {
							d *= p_factors[i]
							mu = -mu
						}
					}
					if mu == 1 {
						sum += cnt[d]
					} else {
						sum -= cnt[d]
					}
				}
				cached_P[r] = sum
			}

			term := (int64(C[g]) * int64(cached_P[r])) % MOD
			ans = (ans + term) % MOD
		}
	}

	fmt.Println(ans)
}