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 double EPS = 1e-12;
const int INF = 999999999;
int m, n, tot;
char g0[5000], g[5000];
short f0[5000][4], f[5000][4];
int Id(char c) {
  switch (c) {
    case 'U':
      return 0;
    case 'R':
      return 1;
    case 'D':
      return 2;
    case 'L':
      return 3;
  }
  return -1;
}
void Read() {
  char buf[5001];
  scanf("%d%d", &m, &n);
  for (int i = 0; i < m; ++i) {
    scanf("%s", buf);
    for (int j = 0; j < n; ++j) g0[i * n + j] = Id(buf[j]);
  }
  tot = m * n;
  for (int i = 0; i < tot; ++i) {
    f0[i][0] = i;
    if (i >= n && g0[i] == -1) f0[i][0] = i - n;
    f0[i][3] = i;
    if (i % n != 0 && g0[i] == -1) f0[i][3] = i - 1;
  }
  for (int i = tot - 1; i >= 0; --i) {
    f0[i][2] = i;
    if (i < tot - n && g0[i] == -1) f0[i][2] = i + n;
    f0[i][1] = i;
    if ((i + 1) % n != 0 && g0[i] == -1) f0[i][1] = i + 1;
  }
}
void Remove(int i) {
  g[i] = -1;
  if (i >= n) f[i][0] = i - n;
  if (i % n != 0) f[i][3] = i - 1;
  if (i < tot - n) f[i][2] = i + n;
  if ((i + 1) % n != 0) f[i][1] = i + 1;
}
int Find(int i, int d) {
  if (f[i][d] == i) return i;
  return f[i][d] = Find(f[i][d], d);
}
int Com(int i) {
  memcpy(g, g0, sizeof(g));
  memcpy(f, f0, sizeof(f));
  int res = 0;
  while (1) {
    ++res;
    int d = g[i];
    Remove(i);
    int next = Find(i, d);
    if (g[next] == -1) break;
    i = next;
  }
  return res;
}
void Solve() {
  int res = 0;
  int count = 0;
  for (int i = 0; i < tot; ++i)
    if (g0[i] != -1) {
      int w = Com(i);
      if (w > res) {
        res = w;
        count = 0;
      }
      if (w == res) ++count;
    }
  printf("%d %d\n", res, count);
}
int main() {
  Read();
  Solve();
  return 0;
}
