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;
template <typename T>
inline bool uax(T &x, T y) {
  return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
  return (y < x) ? x = y, true : false;
}
template <typename T>
void kek(T ans) {
  cout << ans << endl;
  exit(0);
}
const int MOD = (int)1e9 + 7;
const long long INF = (long long)1e18 + 42;
int dir[512];
int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  dir['L'] = 0, dir['R'] = 1, dir['U'] = 2, dir['D'] = 3;
  int n, m;
  cin >> n >> m;
  vector<string> a(n);
  for (auto &s : a) cin >> s;
  vector<array<int, 4> > cells(n * m);
  for (int i = 0; i < n; ++i) {
    int p = -1;
    for (int j = 0; j < m; ++j) {
      cells[i * m + j][0] = p;
      if (a[i][j] != '.') p = i * m + j;
    }
    p = -1;
    for (int j = m - 1; j >= 0; --j) {
      cells[i * m + j][1] = p;
      if (a[i][j] != '.') p = i * m + j;
    }
  }
  for (int j = 0; j < m; ++j) {
    int p = -1;
    for (int i = 0; i < n; ++i) {
      cells[i * m + j][2] = p;
      if (a[i][j] != '.') p = i * m + j;
    }
    p = -1;
    for (int i = n - 1; i >= 0; --i) {
      cells[i * m + j][3] = p;
      if (a[i][j] != '.') p = i * m + j;
    }
  }
  int ans = 0, cnt = n * m;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < m; ++j)
      if (a[i][j] != '.') {
        auto cp = cells;
        int cur = 0;
        int c = i * m + j;
        while (~c) {
          ++cur;
          for (int d = 0; d < 4; ++d)
            if (~cells[c][d]) cells[cells[c][d]][d ^ 1] = cells[c][d ^ 1];
          c = cells[c][dir[a[c / m][c % m]]];
        }
        if (uax(ans, cur)) cnt = 0;
        cnt += ans == cur;
        swap(cp, cells);
      }
  }
  cout << ans << ' ' << cnt << '\n';
}
