```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}

	for i := 0; i < t; i++ {
		solve(in, out)
	}
}

type Robot struct {
	id  int
	pos int
	dir byte
}

func solve(in *bufio.Reader, out *bufio.Writer) {
	var n, m int
	fmt.Fscan(in, &n, &m)

	positions := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &positions[i])
	}

	robots := make([]Robot, n)
	for i := 0; i < n; i++ {
		var d string
		fmt.Fscan(in, &d)
		robots[i] = Robot{
			id:  i,
			pos: positions[i],
			dir: d[0],
		}
	}

	var even, odd []Robot
	for _, r := range robots {
		if r.pos%2 == 0 {
			even = append(even, r)
		} else {
			odd = append(odd, r)
		}
	}

	ans := make([]int, n)
	for i := range ans {
		ans[i] = -1
	}

	calc(even, m, ans)
	calc(odd, m, ans)

	for i := 0; i < n; i++ {
		if i > 0 {
			out.WriteByte(' ')
		}
		fmt.Fprint(out, ans[i])
	}
	out.WriteByte('\n')
}

func calc(robs []Robot, m int, ans []int) {
	if len(robs) == 0 {
		return
	}
	sort.Slice(robs, func(i, j int) bool {
		return robs[i].pos < robs[j].pos
	})

	var stack []int
	for i, r := range robs {
		if r.dir == 'R' {
			stack = append(stack, i)
		} else {
			if len(stack) > 0 {
				topIdx := stack[len(stack)-1]
				stack = stack[:len(stack)-1]

				topR := robs[topIdx]
				eff := topR.pos
				if topR.dir == 'L' {
					eff = -topR.pos
				}

				time := (r.pos - eff) / 2
				ans[r.id] = time
				ans[topR.id] = time
			} else {
				stack = append(stack, i)
			}
		}
	}

	for len(stack) >= 2 {
		idxA := stack[len(stack)-1]
		idxB := stack[len(stack)-2]
		stack = stack[:len(stack)-2]

		rA := robs[idxA]
		rB := robs[idxB]

		effA := rA.pos
		if rA.dir == 'L' {
			effA = -rA.pos
		}
		effB := rB.pos
		if rB.dir == 'L' {
			effB = -rB.pos
		}

		time := (2*m - effA - effB) / 2
		ans[rA.id] = time
		ans[rB.id] = time
	}
}
```