```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(in, &t)
	for ; t > 0; t-- {
		var n int
		var k int64
		fmt.Fscan(in, &n, &k)
		a := make([]int64, n+2)
		b := make([]int, n+2)
		for i := 1; i <= n; i++ {
			fmt.Fscan(in, &a[i])
		}
		for i := 1; i <= n; i++ {
			fmt.Fscan(in, &b[i])
		}
		var S int64 = 0
		for i := 1; i <= n; i++ {
			S += a[i]
		}
		pref := make([]int64, n+2)
		for i := 1; i <= n; i++ {
			pref[i] = pref[i-1] + a[i]
		}
		cheap := []int{}
		for i := 1; i <= n; i++ {
			if b[i] == 1 {
				cheap = append(cheap, i)
			}
		}
		cc := len(cheap)
		ans := make([]int64, n+2)
		if cc == 0 {
			for i := 1; i <= n; i++ {
				ans[i] = 2 * S
			}
		} else {
			gap_T := make([]int64, cc)
			for jj := 0; jj < cc; jj++ {
				st := cheap[jj]
				en := 0
				if jj+1 < cc {
					en = cheap[jj+1]
				} else {
					en = cheap[0]
				}
				var tt int64 = 0
				if st < en {
					tt = pref[en-1] - pref[st-1]
				} else {
					tt = pref[n] - pref[st-1] + pref[en-1]
				}
				gap_T[jj] = tt
			}
			var base int64 = 0
			for jj := 0; jj < cc; jj++ {
				if gap_T[jj]-k > 0 {
					base += gap_T[jj] - k
				}
			}
			for i := 1; i <= n; i++ {
				if b[i] == 1 {
					ans[i] = S + base
				} else {
					idx := sort.SearchInts(cheap, i)
					var jj int
					if idx == cc {
						jj = cc - 1
					} else if cheap[idx] == i {
						continue
					} else if idx == 0 {
						jj = cc - 1
					} else {
						jj = idx - 1
					}
					st := cheap[jj]
					en := 0
					if jj+1 < cc {
						en = cheap[jj+1]
					} else {
						en = cheap[0]
					}
					var t_after int64 = 0
					l := i
					rr := en - 1
					if l <= rr {
						t_after = pref[rr] - pref[l-1]
					} else {
						t_after = pref[n] - pref[l-1] + pref[rr]
					}
					var t_before int64 = 0
					l2 := st
					rr2 := i - 1
					if l2 <= rr2 {
						t_before = pref[rr2] - pref[l2-1]
					} else if rr2 >= 1 {
						t_before = pref[n] - pref[l2-1] + pref[rr2]
					}
					orig_forced := int64(0)
					if gap_T[jj]-k > 0 {
						orig_forced = gap_T[jj] - k
					}
					f_before := int64(0)
					if t_before > 0 {
						if t_before-k > 0 {
							f_before = t_before - k
						}
					}
					f_after := t_after
					this_add := base - orig_forced + f_after + f_before
					ans[i] = S + this_add
				}
			}
		}
		for i := 1; i <= n; i++ {
			if i > 1 {
				fmt.Print(" ")
			}
			fmt.Print(ans[i])
		}
		fmt.Println()
	}
}
```