```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD = 998244353
const G = 3

func pow(a, b int64) int64 {
	res := int64(1)
	a %= MOD
	for b > 0 {
		if b%2 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		b /= 2
	}
	return res
}

func ntt(a []int64, invert bool) {
	n := len(a)
	j := 0
	for i := 1; i < n; i++ {
		bit := n >> 1
		for j&bit != 0 {
			j ^= bit
			bit >>= 1
		}
		j ^= bit
		if i < j {
			a[i], a[j] = a[j], a[i]
		}
	}
	for l := 2; l <= n; l <<= 1 {
		half := l >> 1
		wLen := pow(G, (MOD-1)/int64(l))
		if invert {
			wLen = pow(wLen, MOD-2)
		}
		for i := 0; i < n; i += l {
			w := int64(1)
			for k := 0; k < half; k++ {
				u := a[i+k]
				v := a[i+k+half] * w % MOD
				a[i+k] = (u + v) % MOD
				a[i+k+half] = (u - v + MOD) % MOD
				w = w * wLen % MOD
			}
		}
	}
	if invert {
		nInv := pow(int64(n), MOD-2)
		for i := 0; i < n; i++ {
			a[i] = a[i] * nInv % MOD
		}
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	if !scanner.Scan() {
		return
	}
	var l int64 = 0
	for _, b := range scanner.Bytes() {
		l = l*10 + int64(b-'0')
	}

	scanner.Scan()
	var t int64 = 0
	for _, b := range scanner.Bytes() {
		t = t*10 + int64(b-'0')
	}

	scanner.Scan()
	n := 0
	for _, b := range scanner.Bytes() {
		n = n*10 + int(b-'0')
	}

	speeds := make([]int, n)
	maxV := 0
	for i := 0; i < n; i++ {
		scanner.Scan()
		v := 0
		for _, b := range scanner.Bytes() {
			v = v*10 + int(b-'0')
		}
		speeds[i] = v
		if v > maxV {
			maxV = v
		}
	}

	size := 1
	for size <= 2*maxV {
		size <<= 1
	}

	A := make([]int64, size)
	B := make([]int64, size)
	for _, v := range speeds {
		A[v] = 1
		B[maxV-v] = 1
	}

	ntt(A, false)
	ntt(B, false)

	sumFFT := make([]int64, size)
	diffFFT := make([]int64, size)
	for i := 0; i < size; i++ {
		sumFFT[i] = A[i] * A[i] % MOD
		diffFFT[i] = A[i] * B[i] % MOD
	}

	ntt(sumFFT, true)
	ntt(diffFFT, true)

	maxS := 2 * maxV
	S := make([]bool, maxS+1)

	for _, v := range speeds {
		sumFFT[2*v] = (sumFFT[2*v] - 1 + MOD) % MOD
	}

	for i := 1; i <= maxS; i++ {
		if sumFFT[i] > 0 {
			S[i] = true
		}
	}
	for i := 1; i <= maxV; i++ {
		if diffFFT[maxV+i] > 0 {
			S[i] = true
		}
	}

	hasMultiple := make([]bool, maxS+1)
	for i := 1; i <= maxS; i++ {
		if S[i] {
			hasMultiple[i] = true
		}
	}

	inSPrime := make([]bool, maxS+1)
	for i := 1; i <= maxS; i++ {
		for j := i; j <= maxS; j += i {
			if hasMultiple[j] {
				inSPrime[i] = true
				break
			}
		}
	}

	minPrime := make([]int, maxS+1)
	for i := 2; i <= maxS; i++ {
		if minPrime[i] == 0 {
			for j := i; j <= maxS; j += i {
				if minPrime[j] == 0 {
					minPrime[j] = i
				}
			}
		}
	}

	var ans int64 = 0
	for b := 1; b <= maxS; b++ {
		if !inSPrime[b] {
			continue
		}

		M := (t * int64(b)) / (2 * l)
		if M == 0 {
			continue
		}

		var primes []int64
		temp := b
		for temp > 1 {
			p := minPrime[temp]
			primes = append(primes, int64(p))
			for temp%p == 0 {
				temp /= p
			}
		}

		k := len(primes)
		var count int64 = 0
		for mask := 0; mask < (1 << k); mask++ {
			prod := int64(1)
			bits := 0
			for i := 0; i < k; i++ {
				if (mask & (1 << i)) != 0 {
					prod *= primes[i]
					bits++
				}
			}
			term := M / prod
			if bits%2 == 1 {
				count -= term
			} else {
				count += term
			}
		}
		count %= 1000000007
		ans = (ans + count) % 1000000007
	}

	fmt.Println(ans)
}
```