package main

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

type Node struct {
	w   int64
	gid int
}

type Op struct {
	x  int
	dir byte
}

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

	var n int
	if _, err := fmt.Fscan(in, &n); err != nil {
		return
	}
	a := make([]int64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &a[i])
	}
	var k int
	fmt.Fscan(in, &k)
	b := make([]int64, k)
	for i := 0; i < k; i++ {
		fmt.Fscan(in, &b[i])
	}

	segEnds := make([]int, 0, k)
	sum := int64(0)
	j := 0
	start := 0
	for i := 0; i < n; i++ {
		if j >= k {
			fmt.Fprintln(out, "NO")
			return
		}
		sum += a[i]
		if sum == b[j] {
			segEnds = append(segEnds, i)
			j++
			sum = 0
			start = i + 1
		} else if sum > b[j] {
			fmt.Fprintln(out, "NO")
			return
		}
	}
	if j != k || start != n {
		fmt.Fprintln(out, "NO")
		return
	}

	cur := make([]Node, 0, n)
	segIdx := 0
	end := segEnds[segIdx]
	for i := 0; i < n; i++ {
		cur = append(cur, Node{w: a[i], gid: segIdx + 1})
		if i == end && segIdx+1 < k {
			segIdx++
			end = segEnds[segIdx]
		}
	}

	ops := make([]Op, 0, n-k)

	findBlock := func(g int) (int, int, int) {
		L, R := -1, -1
		cnt := 0
		for i := 0; i < len(cur); i++ {
			if cur[i].gid == g {
				if cnt == 0 {
					L = i
				}
				R = i
				cnt++
			}
		}
		return L, R, cnt
	}

	for g := 1; g <= k; g++ {
		L, R, cnt := findBlock(g)
		if cnt == 0 {
			fmt.Fprintln(out, "NO")
			return
		}
		if cnt == 1 {
			continue
		}
		maxw := cur[L].w
		for i := L; i <= R; i++ {
			if cur[i].w > maxw {
				maxw = cur[i].w
			}
		}
		p := -1
		for i := L; i <= R; i++ {
			if cur[i].w == maxw {
				leftOk := (i-1 >= L && cur[i-1].w < cur[i].w)
				rightOk := (i+1 <= R && cur[i+1].w < cur[i].w)
				if leftOk || rightOk {
					p = i
					break
				}
			}
		}
		if p == -1 {
			fmt.Fprintln(out, "NO")
			return
		}

		L, R, _ = findBlock(g)
		leftPossible := (p-1 >= L && cur[p-1].gid == g && cur[p-1].w < cur[p].w)
		rightPossible := (p+1 <= R && cur[p+1].gid == g && cur[p+1].w < cur[p].w)

		if leftPossible {
			for p-1 >= 0 && cur[p-1].gid == g && cur[p-1].w < cur[p].w {
				ops = append(ops, Op{x: p + 1, dir: 'L'})
				cur[p].w += cur[p-1].w
				cur = append(cur[:p-1], cur[p:]...)
				p = p - 1
			}
			for p+1 < len(cur) && cur[p+1].gid == g {
				if !(cur[p+1].w < cur[p].w) {
					fmt.Fprintln(out, "NO")
					return
				}
				ops = append(ops, Op{x: p + 1, dir: 'R'})
				cur[p].w += cur[p+1].w
				cur = append(cur[:p+1], cur[p+2:]...)
			}
		} else if rightPossible {
			for p+1 < len(cur) && cur[p+1].gid == g && cur[p+1].w < cur[p].w {
				ops = append(ops, Op{x: p + 1, dir: 'R'})
				cur[p].w += cur[p+1].w
				cur = append(cur[:p+1], cur[p+2:]...)
			}
			for p-1 >= 0 && cur[p-1].gid == g {
				if !(cur[p-1].w < cur[p].w) {
					fmt.Fprintln(out, "NO")
					return
				}
				ops = append(ops, Op{x: p + 1, dir: 'L'})
				cur[p].w += cur[p-1].w
				cur = append(cur[:p-1], cur[p:]...)
				p = p - 1
			}
		} else {
			fmt.Fprintln(out, "NO")
			return
		}
	}

	if len(cur) != k {
		fmt.Fprintln(out, "NO")
		return
	}
	for i := 0; i < k; i++ {
		if cur[i].w != b[i] {
			fmt.Fprintln(out, "NO")
			return
		}
	}

	fmt.Fprintln(out, "YES")
	for _, op := range ops {
		fmt.Fprintf(out, "%d %c\n", op.x, op.dir)
	}
}