```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	// Use buffered scanner for fast reading
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	// Helper function to scan the next integer
	scanInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	// Read N
	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	// Read sequence A
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = scanInt()
	}

	// Read K
	k := scanInt()

	// Read sequence B
	b := make([]int, k)
	for i := 0; i < k; i++ {
		b[i] = scanInt()
	}

	// Step 1: Partition A into segments corresponding to elements in B
	segments := make([][]int, 0, k)
	curr := 0
	for i := 0; i < k; i++ {
		target := b[i]
		currentSum := 0
		var seg []int
		for currentSum < target && curr < n {
			val := a[curr]
			seg = append(seg, val)
			currentSum += val
			curr++
		}
		// If the segment sum doesn't match the target in B, it's impossible
		if currentSum != target {
			fmt.Println("NO")
			return
		}
		segments = append(segments, seg)
	}

	// If we haven't used all elements of A, it's impossible
	if curr != n {
		fmt.Println("NO")
		return
	}

	// Step 2: Validate each segment and generate moves
	var sb strings.Builder
	for i, seg := range segments {
		if len(seg) == 1 {
			continue
		}

		// Find maximum value in the segment
		maxVal := -1
		for _, v := range seg {
			if v > maxVal {
				maxVal = v
			}
		}

		pivot := -1
		// direction: 1 for Left ('L'), 2 for Right ('R')
		direction := 0

		// We need to find a monster with the maximum weight in the segment
		// that has a neighbor with strictly smaller weight.
		for j, v := range seg {
			if v == maxVal {
				// Check left neighbor
				if j > 0 && seg[j-1] < maxVal {
					pivot = j
					direction = 1
					break
				}
				// Check right neighbor
				if j < len(seg)-1 && seg[j+1] < maxVal {
					pivot = j
					direction = 2
					break
				}
			}
		}

		// If no such monster exists, the segment cannot be collapsed
		if pivot == -1 {
			fmt.Println("NO")
			return
		}

		// Base index: previous segments i have been collapsed to 1 monster each.
		// So this segment starts at index i + 1 in the current queue.
		base := i + 1

		if direction == 1 { // Eat Left
			// First, eat the immediate left neighbor
			sb.WriteString(fmt.Sprintf("%d L\n", base+pivot))
			currIdx := base + pivot - 1

			// Eat remaining left neighbors
			for x := 0; x < pivot-1; x++ {
				sb.WriteString(fmt.Sprintf("%d L\n", currIdx))
				currIdx--
			}

			// Eat all right neighbors
			countRight := len(seg) - 1 - pivot
			for x := 0; x < countRight; x++ {
				sb.WriteString(fmt.Sprintf("%d R\n", currIdx))
			}

		} else { // Eat Right
			// First, eat the immediate right neighbor
			sb.WriteString(fmt.Sprintf("%d R\n", base+pivot))
			currIdx := base + pivot

			// Eat remaining right neighbors
			countRight := len(seg) - pivot - 2
			for x := 0; x < countRight; x++ {
				sb.WriteString(fmt.Sprintf("%d R\n", currIdx))
			}

			// Eat all left neighbors
			countLeft := pivot
			for x := 0; x < countLeft; x++ {
				sb.WriteString(fmt.Sprintf("%d L\n", currIdx))
				currIdx--
			}
		}
	}

	fmt.Println("YES")
	fmt.Print(sb.String())
}
```