10 10
.L.....R..
.........U
..D....D..
.R......L.
....L.....
.........D
......U...
D....R....
...U......
........L.
 5 5
DD..D
.....
LU...
U...U
.UL.U
 1 1
U
 5 5
UD..L
RRD..
..RDD
UUL..
DDLRR
 19 23
U..U..R........L...D...
.D.....UL.U.U........DR
..D.U..D....L......R...
D.......RL.L....D.....R
U..D.....U...U.L..D...U
...........L...........
U....U....D.U......LRR.
......RL...U...L.......
DLU..U......UU.U.U.D...
...........D....U......
U...DL......LL.....R...
...U..DD..........LD...
.R.........D.....UU...U
....D......R..........D
.L..........R.....L....
.R........L.LL....R....
..R...D........R....D..
.LR.R..LDU.DDRL......U.
...LL.....D.....DD.....
 11 29
URRUUDDLURLRDDLLRLDUDR.UDLLD.
LRRUDLUDLDULUDL.DURDRR.RRLLRR
D.DUDDURLRDDULDUDDUDDURRDLD.L
.RULURURRDLRRRLUUUU.RDLDLRRRL
.RLDDU.UUULUURURRLLUU.RLDRDUD
LRL.URRRDDURUURUDRRDLDDULRDRL
RLULDU.LRDUDRLDLRDDDDRUUDRDLL
DLUDURRDDUDLLDLLUURLDRUURRLUL
L.RRURRDDRRURRRDDUDRRDULR.LUR
LDLRULURRUULRDUUULLU.LLU.LLLL
DUURDULDDUDLRUUDRUULURLD.RL.U
 2 2
RD
UL
 1 10
LLLLLRRRRR
 3 3
...
...
..R
 17 13
...LD.UR.RUU.
LDLULDUDRRDRL
DD.RRLRUR.UD.
RU...D...LD..
.UR.R...URUUD
.RURD.RLR.D.R
.UUU.RU...UR.
UUUU.R.......
RL.LRU.UD.DUD
LD.DRURRLRDRL
.DR..UULUDDR.
LRLURRUUDDLUR
.LRDDLLR.L.DU
DRUDLLD.LRRU.
..DL.UDL.DUL.
U.DL..D..U.RD
RR.R...RL.L..

2 2
 4 1
 1 1
 8 3
 9 1
 94 1
 4 4
 5 2
 1 1
 24 2

#include <bits/stdc++.h>
using namespace std;
const int L = 0, R = 1, U = 2, D = 3;
const int maxn = 5005;
class Node {
 public:
  int dir, l, r, u, d;
} a[maxn], b[maxn];
int n, m;
char s[maxn];
inline int id(int x, int y) { return x * m + y; }
inline void build(int x, int y) {
  Node &u = a[id(x, y)];
  int nx, ny;
  for (nx = x, ny = y - 1; ny >= 0 && s[id(nx, ny)] == '.'; --ny)
    ;
  if (ny < 0)
    u.l = -1;
  else
    u.l = id(nx, ny);
  for (nx = x, ny = y + 1; ny < m && s[id(nx, ny)] == '.'; ++ny)
    ;
  if (ny >= m)
    u.r = -1;
  else
    u.r = id(nx, ny);
  for (nx = x - 1, ny = y; nx >= 0 && s[id(nx, ny)] == '.'; --nx)
    ;
  if (nx < 0)
    u.u = -1;
  else
    u.u = id(nx, ny);
  for (nx = x + 1, ny = y; nx < n && s[id(nx, ny)] == '.'; ++nx)
    ;
  if (nx >= n)
    u.d = -1;
  else
    u.d = id(nx, ny);
  return;
}
inline void connectX(int u, int v) {
  if (~u) b[u].r = v;
  if (~v) b[v].l = u;
}
inline void connectY(int u, int v) {
  if (~u) b[u].d = v;
  if (~v) b[v].u = u;
  return;
}
inline void erase(int u) {
  connectX(b[u].l, b[u].r);
  connectY(b[u].u, b[u].d);
  return;
}
inline void dfs(int x, int &res) {
  Node &u = b[x];
  ++res;
  if (u.dir == L) {
    if (!~u.l) return;
    erase(x);
    dfs(u.l, res);
  } else if (u.dir == R) {
    if (!~u.r) return;
    erase(x);
    dfs(u.r, res);
  } else if (u.dir == U) {
    if (!~u.u) return;
    erase(x);
    dfs(u.u, res);
  } else {
    if (!~u.d) return;
    erase(x);
    dfs(u.d, res);
  }
  return;
}
int main() {
  cin >> n >> m;
  for (int i = (0); i < (n); ++i) {
    string buf;
    cin >> buf;
    for (int j = (0); j < (m); ++j) {
      s[id(i, j)] = buf[j];
      if (buf[j] == 'L')
        a[id(i, j)].dir = L;
      else if (buf[j] == 'R')
        a[id(i, j)].dir = R;
      else if (buf[j] == 'U')
        a[id(i, j)].dir = U;
      else if (buf[j] == 'D')
        a[id(i, j)].dir = D;
    }
  }
  for (int x = (0); x < (n); ++x)
    for (int y = (0); y < (m); ++y)
      a[id(x, y)].l = a[id(x, y)].r = a[id(x, y)].u = a[id(x, y)].d = -1;
  for (int x = (0); x < (n); ++x)
    for (int y = (0); y < (m); ++y) build(x, y);
  int ans = 0, cnt = 0;
  for (int i = (0); i < (n); ++i)
    for (int j = (0); j < (m); ++j)
      if (s[id(i, j)] != '.') {
        for (int x = (0); x < (n); ++x)
          for (int y = (0); y < (m); ++y) b[id(x, y)] = a[id(x, y)];
        int res = 0;
        dfs(id(i, j), res);
        if (res > ans)
          ans = res, cnt = 1;
        else if (res == ans)
          ++cnt;
      }
  printf("%d %d\n", ans, cnt);
  return 0;
}
