package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

type Move struct {
	w    int64
	side byte
}

func opposite(c byte) byte {
	if c == 'L' {
		return 'R'
	}
	return 'L'
}

func validate(moves []Move, s []byte) bool {
	if len(moves) != len(s) {
		return false
	}
	var d int64
	for i, mv := range moves {
		if mv.side == 'L' {
			d += mv.w
		} else {
			d -= mv.w
		}
		if d == 0 {
			return false
		}
		if d > 0 {
			if s[i] != 'L' {
				return false
			}
		} else {
			if s[i] != 'R' {
				return false
			}
		}
	}
	return true
}

func find(parent []int, x int) int {
	y := x
	for parent[y] != y {
		y = parent[y]
	}
	for parent[x] != x {
		nx := parent[x]
		parent[x] = y
		x = nx
	}
	return y
}

func attempt(arr []int64, runSigns []byte, runLens []int, s []byte, fillerMode int, adaptive bool) ([]Move, bool) {
	n := len(arr)
	k := len(runSigns)
	m := n - k
	fillers := arr[:m]
	anchors := arr[m:]

	moves := make([]Move, 0, n)

	l, r := 0, m-1
	globalHigh := true
	if fillerMode == 3 {
		globalHigh = false
	}

	var parent []int
	if adaptive {
		parent = make([]int, k+1)
		for i := 0; i <= k; i++ {
			parent[i] = i
		}
	}

	var diff int64

	for j := 0; j < k; j++ {
		var a int64
		if adaptive {
			pos := sort.Search(len(anchors), func(i int) bool { return anchors[i] > diff })
			pos = find(parent, pos)
			if pos >= len(anchors) {
				return nil, false
			}
			a = anchors[pos]
			parent[pos] = find(parent, pos+1)
		} else {
			a = anchors[j]
			if j > 0 && a <= diff {
				return nil, false
			}
		}

		moves = append(moves, Move{a, runSigns[j]})
		if j == 0 {
			diff = a
		} else {
			diff = a - diff
		}
		if diff <= 0 {
			return nil, false
		}

		cnt := runLens[j] - 1
		for t := 0; t < cnt; t++ {
			if l > r {
				return nil, false
			}
			var x int64
			switch fillerMode {
			case 0:
				if t%2 == 0 {
					x = fillers[r]
					r--
				} else {
					x = fillers[l]
					l++
				}
			case 1:
				if globalHigh {
					x = fillers[r]
					r--
				} else {
					x = fillers[l]
					l++
				}
				globalHigh = !globalHigh
			case 2:
				if t%2 == 0 {
					x = fillers[l]
					l++
				} else {
					x = fillers[r]
					r--
				}
			case 3:
				if globalHigh {
					x = fillers[r]
					r--
				} else {
					x = fillers[l]
					l++
				}
				globalHigh = !globalHigh
			}

			side := runSigns[j]
			if x < diff {
				side = opposite(side)
				diff -= x
			} else {
				diff += x
			}
			if diff <= 0 {
				return nil, false
			}
			moves = append(moves, Move{x, side})
		}
	}

	if l <= r {
		return nil, false
	}
	if !validate(moves, s) {
		return nil, false
	}
	return moves, true
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	readInt := func() int {
		for p < len(data) && (data[p] == ' ' || data[p] == '\n' || data[p] == '\r' || data[p] == '\t') {
			p++
		}
		sign := 1
		if p < len(data) && data[p] == '-' {
			sign = -1
			p++
		}
		val := 0
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			val = val*10 + int(data[p]-'0')
			p++
		}
		return val * sign
	}
	readString := func() []byte {
		for p < len(data) && (data[p] == ' ' || data[p] == '\n' || data[p] == '\r' || data[p] == '\t') {
			p++
		}
		start := p
		for p < len(data) && data[p] != ' ' && data[p] != '\n' && data[p] != '\r' && data[p] != '\t' {
			p++
		}
		return data[start:p]
	}

	n := readInt()
	arr := make([]int64, n)
	for i := 0; i < n; i++ {
		arr[i] = int64(readInt())
	}
	s := append([]byte(nil), readString()...)

	sort.Slice(arr, func(i, j int) bool { return arr[i] < arr[j] })

	runSigns := make([]byte, 0)
	runLens := make([]int, 0)
	for i := 0; i < n; {
		j := i
		for j < n && s[j] == s[i] {
			j++
		}
		runSigns = append(runSigns, s[i])
		runLens = append(runLens, j-i)
		i = j
	}

	type Opt struct {
		fillerMode int
		adaptive   bool
	}

	opts := []Opt{
		{0, true},
		{0, false},
		{1, true},
		{1, false},
		{2, true},
		{2, false},
		{3, true},
		{3, false},
	}

	var ans []Move
	ok := false
	for _, op := range opts {
		if res, good := attempt(arr, runSigns, runLens, s, op.fillerMode, op.adaptive); good {
			ans = res
			ok = true
			break
		}
	}

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

	if !ok {
		w.WriteString("-1\n")
		return
	}

	out := make([]byte, 0, n*20)
	for _, mv := range ans {
		out = strconv.AppendInt(out, mv.w, 10)
		out = append(out, ' ', mv.side, '\n')
	}
	w.Write(out)
}