object Main {

  import scala.collection.immutable.Queue

  case class Point(x: Int, y: Int) {
    def move(dx: Int, dy: Int): Point =
      Point(x + dx, y + dy)
  }

  def main(args: Array[String]): Unit = {
    val sc = new java.util.Scanner(System.in)

    val sx, sy, tx, ty = sc.nextInt()

    def solve(): List[Point] = {
      val delta = 1000
      val visited = Array.fill(2 * delta, 2 * delta)(false)

      def bfs(vector: Seq[(Int, Int)], start: Point, end: Point): List[Point] = {
        val localVisited = Array.fill(2 * delta, 2 * delta)(false)

        def isVisited(x: Int, y: Int): Boolean =
          visited(y + delta)(x + delta) || localVisited(y + delta)(x + delta)

        def loop(queue: Queue[(Point, List[Point])]): List[Point] =
          if (queue.nonEmpty) {
            val (point, path) = queue.head
            if (point.x == end.x && point.y == end.y) {
              path foreach (point => visited(point.y + delta)(point.x + delta) = true)
              path.reverse
            } else if ((point.x == sx && point.y == sy) ||
                (point.x == tx && point.y == ty) ||
                !isVisited(point.x, point.y)) {
              localVisited(point.y + delta)(point.x + delta) = true
              loop(
                queue.tail.enqueue(vector. map { case (dx, dy) =>
                  (point.move(dx, dy), point :: path)
                }. toList))
            } else loop(queue.tail)
          } else Nil // not reachable
        loop(Queue((Point(start.x, start.y), Nil)))
      }

      val vector = Seq((0, 1), (1, 0), (0, -1), (-1, 0))

      bfs(vector, Point(sx, sy), Point(tx, ty)) ++
        bfs(vector, Point(tx, ty), Point(sx, sy)) ++
          bfs(vector, Point(sx, sy), Point(tx, ty)) ++
            bfs(vector, Point(tx, ty), Point(sx, sy)) :+ Point(sx, sy)
    }

    println(solve().sliding(2).map { p =>
      val parent = p.head
      val child = p.tail.head
      (child.x - parent.x, child.y - parent.y) match {
        case (0, 1) => 'U'
        case (1, 0) => 'R'
        case (0, -1) => 'D'
        case (-1, 0) => 'L'
      }
    }. mkString)
  }

}
