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;
int n, m;
const int N = 5e3 + 5;
short leftt[N][N], rightt[N][N], up[N][N], down[N][N];
string arr[N];
void compute() {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      leftt[i][j] = up[i][j] = down[i][j] = rightt[i][j] = -1;
      if (arr[i][j] != '.') {
        int x = i - 1;
        while (x >= 0) {
          if (arr[x][j] != '.') {
            up[i][j] = x;
            break;
          }
          x--;
        }
        x = i + 1;
        while (x < n) {
          if (arr[x][j] != '.') {
            down[i][j] = x;
            break;
          }
          x++;
        }
        int y = j - 1;
        while (y >= 0) {
          if (arr[i][y] != '.') {
            leftt[i][j] = y;
            break;
          }
          y--;
        }
        y = j + 1;
        while (y < m) {
          if (arr[i][y] != '.') {
            rightt[i][j] = y;
            break;
          }
          y++;
        }
      }
    }
  }
}
void remove(int r, int c) {
  if (up[r][c] >= 0) {
    int rr = up[r][c];
    down[rr][c] = down[r][c];
  }
  if (leftt[r][c] >= 0) {
    int cc = leftt[r][c];
    rightt[r][cc] = rightt[r][c];
  }
  if (down[r][c] >= 0) {
    int rr = down[r][c];
    up[rr][c] = up[r][c];
  }
  if (rightt[r][c] >= 0) {
    int cc = rightt[r][c];
    leftt[r][cc] = leftt[r][c];
  }
}
int find(int r, int c) {
  int ret = 0;
  int pr = r, pc = c;
  while (pr >= 0 && pc >= 0) {
    ret++;
    remove(pr, pc);
    if (arr[pr][pc] == 'D')
      pr = down[pr][pc];
    else if (arr[pr][pc] == 'R')
      pc = rightt[pr][pc];
    else if (arr[pr][pc] == 'U')
      pr = up[pr][pc];
    else
      pc = leftt[pr][pc];
  }
  return ret;
}
int main() {
  cin >> n >> m;
  for (int i = 0; i < n; i++) cin >> arr[i];
  int mx = 0, cnt = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      compute();
      if (arr[i][j] != '.') {
        int val = find(i, j);
        if (val > mx) {
          mx = val;
          cnt = 1;
        } else if (mx == val)
          cnt++;
      }
    }
  }
  cout << mx << " " << cnt << endl;
  return 0;
}
