package main

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

type Robot struct {
	id  int
	x   int
	dir byte
}

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

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

	for tc := 0; tc < t; tc++ {
		var n, m int
		fmt.Fscan(reader, &n, &m)

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

		var dirStr string
		for {
			var d string
			fmt.Fscan(reader, &d)
			dirStr += d
			if len(dirStr) >= n {
				break
			}
		}

		evenRobots := []Robot{}
		oddRobots := []Robot{}

		for i := 0; i < n; i++ {
			r := Robot{id: i, x: x[i], dir: dirStr[i]}
			if r.x%2 == 0 {
				evenRobots = append(evenRobots, r)
			} else {
				oddRobots = append(oddRobots, r)
			}
		}

		ans := make([]int, n)
		for i := 0; i < n; i++ {
			ans[i] = -1
		}

		process := func(robots []Robot) {
			sort.Slice(robots, func(i, j int) bool {
				return robots[i].x < robots[j].x
			})

			stack := []Robot{}
			for _, r := range robots {
				if r.dir == 'R' {
					stack = append(stack, r)
				} else {
					if len(stack) == 0 {
						stack = append(stack, r)
					} else {
						top := stack[len(stack)-1]
						stack = stack[:len(stack)-1]
						var time int
						if top.dir == 'R' {
							time = (r.x - top.x) / 2
						} else {
							time = (r.x + top.x) / 2
						}
						ans[r.id] = time
						ans[top.id] = time
					}
				}
			}

			for len(stack) >= 2 {
				a := stack[len(stack)-1]
				b := stack[len(stack)-2]
				stack = stack[:len(stack)-2]

				ea := a.x
				if a.dir == 'L' {
					ea = -a.x
				}
				eb := b.x
				if b.dir == 'L' {
					eb = -b.x
				}

				time := m - (ea+eb)/2
				ans[a.id] = time
				ans[b.id] = time
			}
		}

		process(evenRobots)
		process(oddRobots)

		for i := 0; i < n; i++ {
			if i > 0 {
				fmt.Fprint(writer, " ")
			}
			fmt.Fprint(writer, ans[i])
		}
		fmt.Fprintln(writer)
	}
}