#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T>
using vec = std::vector<T>;
template <class T>
using vec2d = std::vector<std::vector<T>>;
template <class T>
vec2d<T> makeVec2d(const int n1, const int n2) {
  return vec2d<T>(n1, vec<T>(n2));
}
template <class T>
vec2d<T> makeVec2d(const int n1, const int n2, const T initValue) {
  return vec2d<T>(n1, vec<T>(n2, initValue));
}
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
struct Input {
  Input(istream &in) : in(&in) {}
  template <class T>
  T next() const {
    T x;
    *in >> x;
    return x;
  }
  int ni() const { return next<int>(); }
  string ns() const { return next<string>(); }
  istream *in;
};
Input in(cin);
class Output {
 private:
  ostream *out;
  template <typename T>
  void printSingle(const T &value) {
    *out << value;
  }

 public:
  Output(ostream &out) : out(&out) {}
  inline void flush() { out->flush(); }
  inline void print() {}
  template <typename T, typename... Ts>
  inline void print(const T &f, const Ts &...args) {
    printSingle(f);
    if (sizeof...(args) != 0) {
      *out << ' ';
      print(args...);
    }
  }
  template <typename... Ts>
  inline void println(const Ts &...args) {
    print(args...);
    *out << '\n';
  }
  template <typename... Ts>
  inline void operator()(const Ts &...args) {
    println(args...);
  }
};
Output out(cout);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
}  // namespace template_util
void solve(istream &inStream, ostream &outStream) {
  in = Input(inStream);
  out = Output(outStream);
  auto n = in.ni();
  auto m = in.ni();
  vec<string> f(n);
  for (int i = 0; i < (n); ++i) {
    f[i] = in.ns();
  }
  int dx[] = {1, 0, -1, 0};
  int dy[] = {0, 1, 0, -1};
  string keys = "DRUL";
  bool checkRight = false, checkDown = false;
  vec<pair<int, int>> q;
  q.push_back({0, 0});
  vec2d<pair<int, int>> parent = makeVec2d<pair<int, int>>(n, m);
  parent[0][0] = {-1, -1};
  vec2d<int> used = makeVec2d<int>(n, m, false);
  used[0][0] = true;
  vec<pair<int, int>> path;
  for (int qi = 0; qi < (q.size()); ++qi) {
    int x = q[qi].first, y = q[qi].second;
    if (f[x][y] == 'F') {
      while (x != -1) {
        path.push_back({x, y});
        auto pp = parent[x][y];
        x = pp.first;
        y = pp.second;
      }
      reverse(path.begin(), path.end());
      break;
    }
    for (int d = 0; d < (4); ++d) {
      int nx = x + dx[d], ny = y + dy[d];
      if (nx >= 0 && ny >= 0 && nx < n && ny < m) {
        if (!used[nx][ny] && f[nx][ny] != '*') {
          parent[nx][ny] = {x, y};
          q.push_back({nx, ny});
          used[nx][ny] = true;
        }
      }
    }
  }
  auto pressDown = [&]() -> pair<int, int> {
    out(keys[0]);
    out.flush();
    auto x = in.ni() - 1;
    auto y = in.ni() - 1;
    return {x, y};
  };
  auto pressUp = [&]() -> pair<int, int> {
    out(keys[2]);
    out.flush();
    auto x = in.ni() - 1;
    auto y = in.ni() - 1;
    return {x, y};
  };
  auto pressRight = [&]() -> pair<int, int> {
    out(keys[1]);
    out.flush();
    auto x = in.ni() - 1;
    auto y = in.ni() - 1;
    return {x, y};
  };
  auto pressLeft = [&]() -> pair<int, int> {
    out(keys[3]);
    out.flush();
    auto x = in.ni() - 1;
    auto y = in.ni() - 1;
    return {x, y};
  };
  for (int i = (1); i <= (path.size() - 1); ++i) {
    int deltaX = path[i].first - path[i - 1].first;
    int deltaY = path[i].second - path[i - 1].second;
    if (deltaX != 0) {
      if (!checkDown) {
        auto p = pressDown();
        if (p == path[i - 1]) {
          swap(keys[0], keys[2]);
          pressDown();
        }
        checkDown = true;
      } else {
        if (deltaX > 0) {
          pressDown();
        } else {
          pressUp();
        }
      }
    } else {
      if (!checkRight) {
        auto p = pressRight();
        if (p == path[i - 1]) {
          swap(keys[1], keys[3]);
          pressRight();
        }
        checkRight = true;
      } else {
        if (deltaY > 0) {
          pressRight();
        } else {
          pressLeft();
        }
      }
    }
  }
}
int main() {
  solve(cin, cout);
  return 0;
}
