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;
#pragma comment(linker, "/STACK:64000000")
inline pair<int, int> dxdy(char c) {
  if (c == 'U') return pair<int, int>(-1, 0);
  if (c == 'D') return pair<int, int>(+1, 0);
  if (c == 'L') return pair<int, int>(0, -1);
  return pair<int, int>(0, +1);
}
int n, m;
vector<string> a;
vector<vector<pair<int, int> > > b;
string s;
int FLAG;
vector<vector<int> > flag;
vector<vector<int> > was;
vector<vector<int> > T;
inline int check(int x, int y) { return (x >= 0 && y >= 0 && x < n && y < m); }
inline void init() {
  cin >> n >> m;
  a.resize(n);
  flag.resize(n);
  T.resize(n);
  was.resize(n);
  for (int i = 0; i < n; ++i) {
    cin >> s;
    a[i] = s;
    T[i].resize(m);
    flag[i].assign(m, -1);
    was[i].assign(m, -1);
  }
}
inline int solve(int x, int y) {
  if (a[x][y] == '.') return 0;
  ++FLAG;
  int res = 0;
  for (;;) {
    ++res;
    was[x][y] = FLAG;
    pair<int, int> cur = dxdy(a[x][y]);
    int dx = cur.first;
    int dy = cur.second;
    if (flag[x][y] != FLAG) {
      T[x][y] = 1;
      flag[x][y] = FLAG;
    }
    int nx = x + T[x][y] * dx;
    int ny = y + T[x][y] * dy;
    int ok = 0;
    while (check(nx, ny)) {
      ++T[x][y];
      if (a[nx][ny] != '.' && was[nx][ny] != FLAG) {
        ok = 1;
        x = nx;
        y = ny;
        break;
      }
      if (a[nx][ny] == a[x][y]) {
        int TT = T[nx][ny] - 1;
        T[x][y] += TT;
        nx += TT * dx;
        ny += TT * dy;
        continue;
      }
      nx += dx;
      ny += dy;
    }
    if (!ok) return res;
  }
  return res;
}
int main() {
  init();
  FLAG = 0;
  int cnt = 0;
  int best = 0;
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      int cur = solve(i, j);
      if (cur > best) {
        best = cur;
        cnt = 0;
      }
      if (cur == best) {
        ++cnt;
      }
    }
  printf("%d %d\n", best, cnt);
  return 0;
}
