```go
package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"math/rand"
	"os"
	"strings"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	n := 0
	fmt.Sscanf(scanner.Text(), "%d", &n)

	senders := make([][2]uint64, n)

	for i := 0; i < n; i++ {
		scanner.Scan()
		line := scanner.Text()
		for j := 0; j < n; j++ {
			if line[j] == '1' {
				if j < 64 {
					senders[i][0] |= 1 << j
				} else {
					senders[i][1] |= 1 << (j - 64)
				}
			}
		}
	}

	a := make([]int, n)
	scanner.Scan()
	fields := strings.Fields(scanner.Text())
	for i := 0; i < n; i++ {
		fmt.Sscanf(fields[i], "%d", &a[i])
	}

	if n <= 23 {
		senders32 := make([]uint32, n)
		for i := 0; i < n; i++ {
			senders32[i] = uint32(senders[i][0])
		}
		for mask := 0; mask < (1 << n); mask++ {
			m := uint32(mask)
			valid := true
			for i := 0; i < n; i++ {
				cnt := bits.OnesCount32(m & senders32[i])
				if cnt == a[i] {
					valid = false
					break
				}
			}
			if valid {
				printSolutionMask(mask, n)
				return
			}
		}
	} else {
		valid := true
		for i := 0; i < n; i++ {
			if 0 == a[i] {
				valid = false
				break
			}
		}
		if valid {
			fmt.Println(0)
			fmt.Println()
			return
		}

		valid = true
		for i := 0; i < n; i++ {
			cnt := bits.OnesCount64(senders[i][0]) + bits.OnesCount64(senders[i][1])
			if cnt == a[i] {
				valid = false
				break
			}
		}
		if valid {
			fmt.Println(n)
			for i := 1; i <= n; i++ {
				if i > 1 {
					fmt.Print(" ")
				}
				fmt.Print(i)
			}
			fmt.Println()
			return
		}

		for k := 0; k < n; k++ {
			valid = true
			for i := 0; i < n; i++ {
				cnt := 0
				if k < 64 {
					if (senders[i][0]>>k)&1 == 1 {
						cnt = 1
					}
				} else {
					if (senders[i][1]>>(k-64))&1 == 1 {
						cnt = 1
					}
				}
				if cnt == a[i] {
					valid = false
					break
				}
			}
			if valid {
				fmt.Println(1)
				fmt.Println(k + 1)
				return
			}
		}

		for iter := 0; iter < 500000; iter++ {
			var m0, m1 uint64
			m0 = rand.Uint64()
			if n > 64 {
				m1 = rand.Uint64()
			}
			if n < 64 {
				m0 &= (1 << n) - 1
			} else if n > 64 {
				m1 &= (1 << (n - 64)) - 1
			}

			valid = true
			for i := 0; i < n; i++ {
				cnt := bits.OnesCount64(m0&senders[i][0]) + bits.OnesCount64(m1&senders[i][1])
				if cnt == a[i] {
					valid = false
					break
				}
			}
			if valid {
				printSolutionBits(m0, m1, n)
				return
			}
		}
	}

	fmt.Println(-1)
}

func printSolutionMask(mask int, n int) {
	res := []int{}
	for i := 0; i < n; i++ {
		if mask&(1<<i) != 0 {
			res = append(res, i+1)
		}
	}
	fmt.Println(len(res))
	if len(res) > 0 {
		for i, v := range res {
			if i > 0 {
				fmt.Print(" ")
			}
			fmt.Print(v)
		}
		fmt.Println()
	} else {
		fmt.Println()
	}
}

func printSolutionBits(m0, m1 uint64, n int) {
	res := []int{}
	for i := 0; i < n && i < 64; i++ {
		if (m0>>i)&1 == 1 {
			res = append(res, i+1)
		}
	}
	for i := 64; i < n; i++ {
		if (m1>>(i-64))&1 == 1 {
			res = append(res, i+1)
		}
	}
	fmt.Println(len(res))
	if len(res) > 0 {
		for i, v := range res {
			if i > 0 {
				fmt.Print(" ")
			}
			fmt.Print(v)
		}
		fmt.Println()
	} else {
		fmt.Println()
	}
}
```