```go
package main

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

func power(base, exp int64) int64 {
	var res int64 = 1
	base %= 1000000007
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % 1000000007
		}
		base = (base * base) % 1000000007
		exp /= 2
	}
	return res
}

func modInverse(n int64) int64 {
	return power(n, 1000000007-2)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(reader, &n)

	a := make([]int64, n)
	for i := 1; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	MOD := int64(1000000007)

	V := make([]int64, 2*n+1)
	V[1] = 1
	for i := 2; i <= n; i++ {
		V[i] = (V[i-1] * a[i-1]) % MOD
	}

	C := make([]int64, n)
	for i := 1; i < n; i++ {
		num := (a[i] - 1) % MOD
		if num < 0 {
			num += MOD
		}
		den := (a[i] * V[i]) % MOD
		C[i] = (num * modInverse(den)) % MOD
	}

	ans := make([]int64, 2*n)

	sumV := make([]int64, n+2)
	for i := n; i >= 1; i-- {
		sumV[i] = (sumV[i+1] + V[i]) % MOD
	}
	for k := 1; k <= 2*n-2; k++ {
		if k+1 <= n {
			ans[k] = sumV[k+1]
		}
	}

	inv2 := modInverse(2)
	inv2_C := make([]int64, n)
	for i := 1; i < n; i++ {
		inv2_C[i] = (inv2 * C[i]) % MOD
	}

	two_V := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		two_V[i] = (2 * V[i]) % MOD
	}

	for S := 3; S <= 2*n; S++ {
		var G int64 = 0
		var m int
		var d int
		if S%2 == 0 {
			m = S / 2
			G = (V[m] * V[m]) % MOD
			d = m - 1
		} else {
			m = S / 2
			G = (two_V[m] * V[S-m]) % MOD
			d = m - 1
		}

		for d >= 1 {
			k := S - 2*d
			
			term := (inv2_C[d] * G) % MOD
			ans[k] += term
			if ans[k] >= MOD {
				ans[k] -= MOD
			}
			
			add := (two_V[d] * V[S-d]) % MOD
			G += add
			if G >= MOD {
				G -= MOD
			}
			
			d--
		}
	}

	writer := bufio.NewWriter(os.Stdout)
	for k := 1; k <= 2*n-2; k++ {
		fmt.Fprint(writer, ans[k])
		if k == 2*n-2 {
			fmt.Fprintln(writer)
		} else {
			fmt.Fprint(writer, " ")
		}
	}
	writer.Flush()
}
```