```go
package main

import (
	"bufio"
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) skip() {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
}

func (fs *FastScanner) NextInt() int {
	fs.skip()
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < len(fs.data) {
		b := fs.data[fs.idx]
		if b < '0' || b > '9' {
			break
		}
		val = val*10 + int(b-'0')
		fs.idx++
	}
	return sign * val
}

func (fs *FastScanner) NextToken() []byte {
	fs.skip()
	start := fs.idx
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		fs.idx++
	}
	return fs.data[start:fs.idx]
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := fs.NextInt()
	for ; t > 0; t-- {
		n := fs.NextInt()
		k := fs.NextInt()

		s := fs.NextToken()
		ones := make([]int, k)

		for i := 0; i < n; i++ {
			a := fs.NextToken()
			for j := 0; j < k; j++ {
				if a[j] == '1' {
					ones[j]++
				}
			}
		}

		m := n + 1
		parent := make([]byte, k*m)
		curr := make([]byte, m)
		next := make([]byte, m)
		curr[0] = 1

		ok := true

		for bit := 0; bit < k; bit++ {
			idx := k - 1 - bit
			sbit := int(s[idx] - '0')
			c0 := ones[idx]
			c1 := n - c0
			row := bit * m
			any := false

			for carry := 0; carry <= n; carry++ {
				if curr[carry] == 0 {
					continue
				}

				sum := carry + c0
				if (sum&1) == sbit {
					nc := (sum - sbit) >> 1
					if next[nc] == 0 {
						next[nc] = 1
						any = true
					}
				}

				sum = carry + c1
				if (sum&1) == sbit {
					nc := (sum - sbit) >> 1
					if next[nc] == 0 {
						next[nc] = 1
						parent[row+nc] = 1
						any = true
					}
				}
			}

			if !any {
				ok = false
				break
			}

			curr, next = next, curr
			for i := 0; i <= n; i++ {
				next[i] = 0
			}
		}

		if !ok || curr[0] == 0 {
			out.WriteString("-1\n")
			continue
		}

		ans := make([]byte, k)
		carry := 0
		for bit := k - 1; bit >= 0; bit-- {
			idx := k - 1 - bit
			ch := parent[bit*m+carry]
			ans[idx] = '0' + ch

			val := ones[idx]
			if ch == 1 {
				val = n - val
			}
			carry = 2*carry + int(s[idx]-'0') - val
		}

		out.Write(ans)
		out.WriteByte('\n')
	}
}
```