```go
package main

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

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

	var n, m int
	var k int64
	fmt.Fscan(in, &n, &m, &k)

	maxRoads := int64(4*n*m - 2*n - 2*m)
	if k > maxRoads {
		fmt.Fprintln(out, "NO")
		return
	}

	fmt.Fprintln(out, "YES")

	type step struct {
		f int64
		s string
	}
	var steps []step

	row, col := 1, 1
	remaining := k

	for remaining > 0 && row <= n {
		if row%2 == 1 {
			// Odd row: go right
			// First, handle the moves across columns
			if col < m {
				// We can move right
				// Pattern: for each step right (except last), we can do a down-up detour if not last row
				// But we need to batch for efficiency
				
				// Calculate how many full "R DU" cycles we can do
				// Each cycle: R, D, U (3 moves) uses 3 from remaining
				// But we can only do this if row < n and we have space
				
				cycles := int64(0)
				if row < n {
					// We can do cycles at columns 1 to m-2 (i.e., after moving to col 2..m-1)
					// Current col is 'col'
					// We will move to col+1, do DU, move to col+2, do DU...
					// Available columns for DU: from current+1 to m-1
					available := int64(m - col - 1)
					if available < 0 {
						available = 0
					}
					// Each cycle uses 3 moves
					maxCycles := remaining / 3
					if maxCycles > available {
						maxCycles = available
					}
					cycles = maxCycles
				}
				
				if cycles > 0 {
					steps = append(steps, step{cycles, "RDU"})
					remaining -= cycles * 3
					col += int(cycles)
				}
				
				// Now handle remaining moves in this row
				// We might need to move right without DU, or do partial DU
				if remaining > 0 && col < m {
					// Move right to next column
					if remaining >= 1 {
						steps = append(steps, step{1, "R"})
						remaining--
						col++
						
						// Try DU if possible and remaining
						if remaining >= 2 && row < n && col < m {
							steps = append(steps, step{1, "DU"})
							remaining -= 2
						}
					}
				}
				
				// If we are at column m or remaining is 0, break to outer
				if remaining == 0 {
					break
				}
			}
			
			// Move down to next row if not last row
			if row < n && remaining > 0 {
				steps = append(steps, step{1, "D"})
				remaining--
				row++
			} else {
				break
			}
		} else {
			// Even row: go left
			if col > 1 {
				cycles := int64(0)
				if row < n {
					// Available columns for DU: from current-1 down to 2
					// Current col is 'col'
					// We will move to col-1, do DU, move to col-2...
					available := int64(col - 2)
					if available < 0 {
						available = 0
					}
					maxCycles := remaining / 3
					if maxCycles > available {
						maxCycles = available
					}
					cycles = maxCycles
				}
				
				if cycles > 0 {
					steps = append(steps, step{cycles, "LDU"})
					remaining -= cycles * 3
					col -= int(cycles)
				}
				
				if remaining > 0 && col > 1 {
					steps = append(steps, step{1, "L"})
					remaining--
					col--
					
					if remaining >= 2 && row < n && col > 1 {
						steps = append(steps, step{1, "DU"})
						remaining -= 2
					}
				}
				
				if remaining == 0 {
					break
				}
			}
			
			if row < n && remaining > 0 {
				steps = append(steps, step{1, "D"})
				remaining--
				row++
			} else {
				break
			}
		}
	}

	// If still remaining, we are at the last row, just move horizontally
	if remaining > 0 && row == n {
		if row%2 == 1 && col < m {
			// Going right
			move := int64(m - col)
			if move > remaining {
				move = remaining
			}
			if move > 0 {
				steps = append(steps, step{move, "R"})
				remaining -= move
			}
		} else if row%2 == 0 && col > 1 {
			// Going left
			move := int64(col - 1)
			if move > remaining {
				move = remaining
			}
			if move > 0 {
				steps = append(steps, step{move, "L"})
				remaining -= move
			}
		}
	}

	// Optimize steps: merge consecutive same direction
	var finalSteps []step
	for _, s := range steps {
		if s.f == 0 {
			continue
		}
		if len(finalSteps) > 0 && finalSteps[len(finalSteps)-1].s == s.s {
			finalSteps[len(finalSteps)-1].f += s.f
		} else {
			finalSteps = append(finalSteps, s)
		}
	}

	// Ensure we don't exceed 3000 steps
	if len(finalSteps) > 3000 {
		// This shouldn't happen with this logic for n,m <= 500
		// But truncate if it does (should not for valid inputs)
		finalSteps = finalSteps[:3000]
	}

	fmt.Fprintln(out, len(finalSteps))
	for _, s := range finalSteps {
		fmt.Fprintln(out, s.f, s.s)
	}
}
```