```go
package main

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

type FastScanner struct {
	data []byte
	idx  int
}

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

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	n := fs.NextInt()
	k := fs.NextInt()

	B := make([]int, n)
	for i := 0; i < n; i++ {
		B[i] = fs.NextInt()
	}

	const MAXEXP = 1 << 20
	const MAXEXP64 = int64(1 << 20)

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer w.Flush()

	maxLen := 20
	if n < maxLen {
		maxLen = n
	}

	oddBinom := func(a, b int) bool {
		return b >= 0 && b <= a && (b&^a) == 0
	}

	contrib := make([][3]bool, maxLen+1)
	any := false
	for length := 1; length <= maxLen; length++ {
		for c := 0; c <= 2; c++ {
			f := n - length - c
			ok := false
			if f == 0 {
				ok = k <= c
			} else if f > 0 && k > c {
				ok = oddBinom(f-1, k-c-1)
			}
			contrib[length][c] = ok
			if ok {
				any = true
			}
		}
	}

	if !any {
		w.WriteByte('0')
		return
	}

	bits := make([]uint8, MAXEXP)

	for l := 0; l < n; l++ {
		b0 := B[l]

		c := 2
		if l == 0 {
			c--
		}
		if l == n-1 {
			c--
		}
		if contrib[1][c] {
			bits[b0] ^= 1
		}

		sum := 0
		length := 1
		for r := l + 1; r < n && length < maxLen; r++ {
			sum += B[r]
			length++

			if sum >= 20 {
				break
			}

			e := int64(b0) << sum
			if e >= MAXEXP64 {
				break
			}

			c := 2
			if l == 0 {
				c--
			}
			if r == n-1 {
				c--
			}
			if contrib[length][c] {
				bits[int(e)] ^= 1
			}
		}
	}

	highest := -1
	for i := MAXEXP - 1; i >= 0; i-- {
		if bits[i] != 0 {
			highest = i
			break
		}
	}

	if highest == -1 {
		w.WriteByte('0')
		return
	}

	out := make([]byte, highest+1)
	p := 0
	for i := highest; i >= 0; i-- {
		if bits[i] != 0 {
			out[p] = '1'
		} else {
			out[p] = '0'
		}
		p++
	}
	w.Write(out)
}
```