output_description: Print `Yes` if S is easily playable, and `No` otherwise.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      S
attempt: #!/usr/bin/env python3
  from collections import defaultdict, deque
  from heapq import heappush, heappop
  from bisect import bisect_left, bisect_right
  import sys, random, itertools, math
  
  sys.setrecursionlimit(10**5)
  input = sys.stdin.readline
  sqrt = math.sqrt
  
  
  def LI():
      return list(map(int, input().split()))
  
  
  def LF():
      return list(map(float, input().split()))
  
  
  def LI_():
      return list(map(lambda x: int(x) - 1, input().split()))
  
  
  def II():
      return int(input())
  
  
  def IF():
      return float(input())
  
  
  def LS():
      return list(map(list, input().split()))
  
  
  def S():
      return list(input().rstrip())
  
  
  def IR(n):
      return [II() for _ in range(n)]
  
  
  def LIR(n):
      return [LI() for _ in range(n)]
  
  
  def FR(n):
      return [IF() for _ in range(n)]
  
  
  def LFR(n):
      return [LI() for _ in range(n)]
  
  
  def LIR_(n):
      return [LI_() for _ in range(n)]
  
  
  def SR(n):
      return [S() for _ in range(n)]
  
  
  def LSR(n):
      return [LS() for _ in range(n)]
  
  
  mod = 1000000007
  inf = float("INF")
  
  
  # A
  def A():
      d = {"Sunny": 1, "Cloudy": 2, "Rainy": 0}
      a = ["Sunny", "Cloudy", "Rainy"]
      print(a[d[input()]])
      return
  
  
  # B
  def B():
      s = S()
      for i, si in enumerate(s):
          if i % 2:
              if si == "R":
                  print("No")
                  return
          else:
              if si == "L":
                  print("No")
                  return
      print("Yes")
      return
  
  
  # C
  def C():
      n, k, q = LI()
      d = [0] * n
      for _ in range(q):
          a = II() - 1
          d[a] += 1
      for a in d:
          if k - (q - a) > 0:
              print("Yes")
          else:
              print("No")
      return
  
  
  # D
  def D():
      (n,) = LI()
      a = LI()
      q = []
      for ai in a:
          heappush(q, ai)
      for _ in range(m):
          heappush(q, heappop(q) / 2)
      ans = 0
      while q:
          ans += int(heappop(q))
      print(ans)
      return
  
  
  # E
  def E():
      return
  
  
  # F
  def F():
      return
  
  
  # Solve
  if __name__ == "__main__":
      B()
  
problem_description: Statement
  
  Takahashi will do a tap dance. The dance is described by a string S where each
  character is `L`, `R`, `U`, or `D`. These characters indicate the positions on
  which Takahashi should step. He will follow these instructions one by one in
  order, starting with the first character.
  
  S is said to be _easily playable_ if and only if it satisfies both of the
  following conditions:
  
    * Every character in an odd position (1-st, 3-rd, 5-th, \ldots) is `R`, `U`, or `D`.
    * Every character in an even position (2-nd, 4-th, 6-th, \ldots) is `L`, `U`, or `D`.
  
  Your task is to print `Yes` if S is easily playable, and `No` otherwise.
samples: [{"input": "RUDLUDR", "output": "Yes\n    \n\nEvery character in an odd position (1-st, 3-rd, 5-th, 7-th) is `R`, `U`, or\n`D`.\n\nEvery character in an even position (2-nd, 4-th, 6-th) is `L`, `U`, or `D`.\n\nThus, S is easily playable.\n\n* * *"}, {"input": "DULL", "output": "No\n    \n\nThe 3-rd character is not `R`, `U`, nor `D`, so S is not easily playable.\n\n* * *"}, {"input": "UUUUUUUUUUUUUUU", "output": "Yes\n    \n\n* * *"}, {"input": "ULURU", "output": "No\n    \n\n* * *"}, {"input": "RDULULDURURLRDULRLR", "output": "Yes"}]