package main

import (
	"bufio"
	"os"
	"strconv"
)

type Ant struct {
	p   int64
	dir int64
	id  int
}

type AntSlice []Ant

func (a AntSlice) Len() int           { return len(a) }
func (a AntSlice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a AntSlice) Less(i, j int) bool { return a[i].p < a[j].p }

type Int64Slice []int64

func (a Int64Slice) Len() int           { return len(a) }
func (a Int64Slice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a Int64Slice) Less(i, j int) bool { return a[i] < a[j] }

func floorDiv(x, m int64) int64 {
	if x >= 0 {
		return x / m
	}
	return (x - m + 1) / m
}

func quickSortAnts(a AntSlice) {
	if len(a) < 2 {
		return
	}
	left, right := 0, len(a)-1
	pivot := len(a) / 2
	a[pivot], a[right] = a[right], a[pivot]
	for i := range a {
		if a[i].p < a[right].p {
			a[left], a[i] = a[i], a[left]
			left++
		}
	}
	a[left], a[right] = a[right], a[left]
	quickSortAnts(a[:left])
	quickSortAnts(a[left+1:])
}

func quickSortInt64(a Int64Slice) {
	if len(a) < 2 {
		return
	}
	left, right := 0, len(a)-1
	pivot := len(a) / 2
	a[pivot], a[right] = a[right], a[pivot]
	for i := range a {
		if a[i] < a[right] {
			a[left], a[i] = a[i], a[left]
			left++
		}
	}
	a[left], a[right] = a[right], a[left]
	quickSortInt64(a[:left])
	quickSortInt64(a[left+1:])
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024*10)

	var scanInt = func() int64 {
		scanner.Scan()
		b := scanner.Bytes()
		var res int64
		for _, v := range b {
			res = res*10 + int64(v-'0')
		}
		return res
	}

	var scanDir = func() int64 {
		scanner.Scan()
		if scanner.Bytes()[0] == 'L' {
			return -1
		}
		return 1
	}

	if !scanner.Scan() {
		return
	}
	var n int64
	for _, v := range scanner.Bytes() {
		n = n*10 + int64(v-'0')
	}

	m := scanInt()
	t := scanInt()

	ants := make(AntSlice, n)
	for i := int64(0); i < n; i++ {
		ants[i] = Ant{
			p:   scanInt() - 1,
			dir: scanDir(),
			id:  int(i),
		}
	}

	quickSortAnts(ants)

	finalPos := make(Int64Slice, n)
	var crosses int64

	for i := int64(0); i < n; i++ {
		end := ants[i].p + t*ants[i].dir
		crosses += floorDiv(end, m)

		modPos := end % m
		if modPos < 0 {
			modPos += m
		}
		finalPos[i] = modPos
	}

	quickSortInt64(finalPos)

	C := crosses % n
	if C < 0 {
		C += n
	}

	ans := make([]int64, n)
	for i := int64(0); i < n; i++ {
		ans[ants[i].id] = finalPos[(C+i)%n] + 1
	}

	writer := bufio.NewWriter(os.Stdout)
	for i := int64(0); i < n; i++ {
		if i > 0 {
			writer.WriteByte(' ')
		}
		writer.WriteString(strconv.FormatInt(ans[i], 10))
	}
	writer.WriteByte('\n')
	writer.Flush()
}