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 MAXN = 5002;
const int N_DIR = 4;
char dir[] = {'U', 'R', 'D', 'L'};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
string grid[MAXN];
string mat[MAXN];
vector<vector<vector<pair<int, int>>>> ashdASDHaOS;
vector<vector<vector<pair<int, int>>>> mov;
int direction[MAXN][MAXN];
inline bool is_in(int x, int y, int n, int m) {
  return 0 <= x && x < n && 0 <= y && y < m;
}
void build(int n, int m) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      if (grid[i][j] == '.') continue;
      for (int k = 0; k < 4; k++) {
        if (grid[i][j] == dir[k]) direction[i][j] = k;
        for (int p = 1;; p++) {
          int x = i + p * dx[k];
          int y = j + p * dy[k];
          if (is_in(x, y, n, m)) {
            if (grid[x][y] != '.') {
              ashdASDHaOS[i][j][k] = {x, y};
              break;
            }
          } else {
            ashdASDHaOS[i][j][k] = {x, y};
            break;
          }
        }
      }
    }
  }
  return;
}
int solve(int x, int y, int n, int m) {
  mov = ashdASDHaOS;
  for (int i = 0; i < n; i++) {
    mat[i] = grid[i];
  }
  int chips = 0;
  while (is_in(x, y, n, m)) {
    chips++;
    mat[x][y] = '.';
    int d = direction[x][y];
    for (int k = 0; k < 4; k++) {
      if (is_in(mov[x][y][k].first, mov[x][y][k].second, n, m)) {
        int nx = mov[x][y][k].first;
        int ny = mov[x][y][k].second;
        mov[nx][ny][k ^ 2] = mov[x][y][k ^ 2];
      }
    }
    pair<int, int> p = mov[x][y][d];
    x = p.first;
    y = p.second;
  }
  return chips;
}
int main(void) {
  int n, m;
  scanf(" %d %d", &n, &m);
  ashdASDHaOS.resize(n);
  for (int i = 0; i < n; i++) {
    ashdASDHaOS[i].resize(m);
  }
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      ashdASDHaOS[i][j].resize(4);
    }
  }
  for (int i = 0; i < n; i++) {
    cin >> grid[i];
  }
  int ans = 0;
  int ways = 1;
  build(n, m);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      if (grid[i][j] == '.') continue;
      int chips = solve(i, j, n, m);
      if (chips > ans) {
        ans = chips;
        ways = 1;
      } else if (chips == ans) {
        ways++;
      }
    }
  }
  printf("%d %d\n", ans, ways);
  return 0;
}
