#!/bin/python
from collections import deque

R, S = map(int, input().split())

# čtení bludiště
maze = []
for y in range(R):
    line = input()

    for x, character in enumerate(line):
        # zapamatujeme si start
        if character == "S":
            start = (x, y)

    maze.append(line)

# směry, kterými se kloužeme
#             pravo   nahoru   levo    dolů
directions = ((1, 0), (0, 1), (-1,0), (0,-1))

# předpočítání hran
# je iterativní, ale koncept je stejný jako rekurzivní (jen začínáme zespoda rekurze)
edges = [[[None] * S for _ in range(R)] for _ in range(4)]

for x in range(S):
    edges[3][0][x] = (x, 0)
    for y in range(1, R):
        edges[3][y][x] = (x, y) if (maze[y - 1][x] == "#" or maze[y][x] == "C") else edges[3][y - 1][x]

for x in range(S):
    edges[1][R - 1][x] = (x, R - 1)
    for y in range(R - 2, -1, -1):
        edges[1][y][x] = (x, y) if (maze[y + 1][x] == "#" or maze[y][x] == "C") else edges[1][y + 1][x]

for y in range(R):
    edges[2][y][0] = (0, y)
    for x in range(1, S):
        edges[2][y][x] = (x, y) if (maze[y][x - 1] == "#" or maze[y][x] == "C") else edges[2][y][x - 1]

for y in range(R):
    edges[0][y][S - 1] = (S - 1, y)
    for x in range(S - 2, -1, -1):
        edges[0][y][x] = (x, y) if (maze[y][x + 1] == "#" or maze[y][x] == "C") else edges[0][y][x + 1]

def precalculated_slide_position(position, direction):
    """Pomocná funkce -- vrátí předpočítanou pozici po klouzání."""
    return edges[directions.index(direction)][position[1]][position[0]]

def positions_to_symbol(p1, p2):
    """Pro pozice p1 a p2 vrátí symbol, který odpovídá, jakým směrem se vydat z p1 do
    p2. Např. positions_to_symbol((0, 0), (10, 0)) vrátí 'L' (kloužeme se doleva)."""
    if p1[0] - p2[0] < 0:
        return "P"
    elif p1[0] - p2[0] > 0:
        return "L"
    elif p1[1] - p2[1] < 0:
        return "D"
    elif p1[1] - p2[1] > 0:
        return "N"

# 2D pole s pozicemi, ze kterých jsme se do daného políčka dostali
explored = [[None] * S for _ in range(R)]
explored[start[1]][start[0]] = start  # do startu jsme se dostali ze startu

queue = deque([start])  # fronta -- děláme prohledávání do šířky

# programujeme prohledávání do šířky
while len(queue) != 0:
    x, y = queue.popleft()

    # zkusíme se klouzat do všech směrů
    for direction in directions:
        xn, yn = precalculated_slide_position((x, y), direction)

        # pokud jsme danou pozici ještě neprozkoumali, přidejme ji do fronty
        # a poznačme, jak jsme se do ní dostali
        if explored[yn][xn] is None:
            explored[yn][xn] = (x, y)
            queue.append((xn, yn))

        # jsme-li u cíle, tak se vracíme zpět po navštívených místech
        if maze[yn][xn] == "C":
            result = ""

            while explored[yn][xn] != (xn, yn):
                prev_xn, prev_yn = explored[yn][xn]
                result += positions_to_symbol((prev_xn, prev_yn), (xn, yn))
                xn, yn = prev_xn, prev_yn

            # vypíšeme cestu obráceně
            print(result[::-1])
            quit()