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

import java.util.*;
import java.io.*;

public class Main{

    BufferedReader in;
    StringTokenizer str = null;
    PrintWriter out;

    private String next() throws Exception{
    	while (str == null || !str.hasMoreElements())
    	    str = new StringTokenizer(in.readLine());
    	return str.nextToken();
    }
    
    private int nextInt() throws Exception{
	   return Integer.parseInt(next());
    }

    int n,m;
    char []a;
    int []l, r, u, d;

    int cur, max, cnt;

    public void run() throws Exception{
    	in = new BufferedReader(new InputStreamReader(System.in));
    	out = new PrintWriter(System.out);
        n = nextInt();
        m = nextInt();
        a = new char[n * m];
        int at = 0;
        for(int i = 0; i < n; ++i) {
            String s = next();
            for(int j = 0; j < m; ++j) {
                a[at++] = s.charAt(j);
            }
        }
        l = new int[n * m];
        r = new int[n * m];
        u = new int[n * m];
        d = new int[n * m];

        for(int i = 0; i < n; ++i) {
            int last = -1;
            for(int j = 0; j < m; ++j) {
                l[i * m + j] = last;
                if (a[i * m + j] != '.') last = i * m + j;
            }
            last = -1;
            for(int j = m - 1; j >= 0; --j) {
                r[i * m + j] = last;
                if (a[i * m + j] != '.') last = i * m + j;
            }
        }

        for(int j = 0; j < m; ++j) {
            int last = -1;
            for(int i = 0; i < n; ++i) {
                u[i * m + j] = last;
                if (a[i * m + j] != '.') last = i * m + j;
            }
            last = -1;
            for(int i = n - 1; i >= 0; --i) {
                d[i * m + j] = last;
                if (a[i * m + j] != '.') last = i * m + j;
            }
        }

        // System.out.println("left = " + Arrays.toString(left));
        // System.out.println("right = " + Arrays.toString(right));
        // System.out.println("up = " + Arrays.toString(up));
        // System.out.println("down = " + Arrays.toString(down));

        cur = 0;
        max = 0;
        cnt = 0;
        for(int i = 0; i < n * m; ++i) {
            if (a[i] == '.') continue;
            dfs(i);
        }

        out.println(max + " " + cnt);
        out.close();
    }

    private void dfs(int i) {
        if (i == -1) return;
        ++cur;
        if (cur > max) {
            max = cur;
            cnt = 1;
        }else if (cur == max) {
            ++cnt;
        }

        if (l[i] > -1) r[l[i]] = r[i];
        if (r[i] > -1) l[r[i]] = l[i];
        if (u[i] > -1) d[u[i]] = d[i];
        if (d[i] > -1) u[d[i]] = u[i];

        if (a[i] == 'U') {
            dfs(u[i]);
        }else if (a[i] == 'D') {
            dfs(d[i]);
        }else if (a[i] == 'R') {
            dfs(r[i]);
        }else if (a[i] == 'L') {
            dfs(l[i]);
        }

        if (l[i] > -1) r[l[i]] = i;
        if (r[i] > -1) l[r[i]] = i;
        if (u[i] > -1) d[u[i]] = i;
        if (d[i] > -1) u[d[i]] = i;

        cur--;
    }

    public static void main(String args[]) throws Exception{
	   new Main().run();
    }
}