```go
package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
	"sort"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

	adj := make([]int, n)
	for i := 0; i < n; i++ {
		var s string
		fmt.Fscan(reader, &s)
		for j := 0; j < n; j++ {
			if s[j] == '1' {
				adj[i] |= (1 << j)
			}
		}
	}

	dp := make([][]int64, 1<<n)
	dpBacking := make([]int64, (1<<n)*n)
	for i := range dp {
		dp[i] = dpBacking[i*n : (i+1)*n]
	}

	for i := 0; i < n; i++ {
		dp[1<<i][i] = 1
	}

	for M := 1; M < (1<<n); M++ {
		for u := 0; u < n; u++ {
			if (M & (1 << u)) != 0 {
				if dp[M][u] > 0 {
					allowed := adj[u] & (^M) & ((1 << n) - 1)
					for allowed > 0 {
						v := bits.TrailingZeros(uint(allowed))
						dp[M|(1<<v)][v] += dp[M][u]
						allowed &= allowed - 1
					}
				}
			}
		}
	}

	SW := make([][]int64, n+1)
	swBacking := make([]int64, (n+1)*(1<<n))
	for i := range SW {
		SW[i] = swBacking[i*(1<<n) : (i+1)*(1<<n)]
	}

	for M := 1; M < (1<<n); M++ {
		var sum int64 = 0
		for u := 0; u < n; u++ {
			if (M & (1 << u)) != 0 {
				sum += dp[M][u]
			}
		}
		l := bits.OnesCount(uint(M))
		SW[l][M] = sum
	}

	for l := 1; l <= n; l++ {
		for i := 0; i < n; i++ {
			for M := 0; M < (1<<n); M++ {
				if (M & (1 << i)) != 0 {
					SW[l][M] += SW[l][M^(1<<i)]
				}
			}
		}
	}

	G := make([]int64, 1<<(n-1))
	memo := make(map[string]int64)

	for mask := 0; mask < (1<<(n-1)); mask++ {
		var sizes []int
		current := 1
		for i := 0; i < n-1; i++ {
			if (mask & (1 << i)) != 0 {
				current++
			} else {
				sizes = append(sizes, current)
				current = 1
			}
		}
		sizes = append(sizes, current)

		sort.Ints(sizes)
		var sb strings.Builder
		for _, s := range sizes {
			sb.WriteByte(byte(s))
		}
		key := sb.String()

		if val, ok := memo[key]; ok {
			G[mask] = val
		} else {
			var total int64 = 0
			for S := 0; S < (1<<n); S++ {
				var prod int64 = 1
				for _, sz := range sizes {
					prod *= SW[sz][S]
				}
				if (n-bits.OnesCount(uint(S)))%2 == 1 {
					total -= prod
				} else {
					total += prod
				}
			}
			memo[key] = total
			G[mask] = total
		}
	}

	for i := 0; i < n-1; i++ {
		for mask := 0; mask < (1<<(n-1)); mask++ {
			if (mask & (1 << i)) == 0 {
				G[mask] -= G[mask|(1<<i)]
			}
		}
	}

	out := bufio.NewWriter(os.Stdout)
	for i := 0; i < (1 << (n - 1)); i++ {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, G[i])
	}
	fmt.Fprintln(out)
	out.Flush()
}
```