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 <cstdio>
#include <cstdlib>
#include <algorithm>

#define SIZE_N 5001
#define SIZE_M 5001
#define INF 1000000

struct dat{short mov[4] ;} ;

int n , m ;
short dx[4] = {-1 , 0 , 1 , 0} ;
short dy[4] = {0 , -1 , 0 , 1} ;
char tab[SIZE_N][SIZE_M] ;

dat lin[SIZE_N][SIZE_M] ;
//dat init[SIZE_N][SIZE_M] ;

//int ans[SIZE_N][SIZE_M] ;
int max , cnt ;

int map(char c)
{
	if(c == 'L') return 0 ;
	if(c == 'R') return 2 ;
	if(c == 'U') return 1 ;
	if(c == 'D') return 3 ;
}

int che(int x , int y)
{
	if(x > 0 && x <= m && y > 0 && y <= n) return 1 ;
	return 0 ;
}
/*
void ini(void)
{
	for(int i = 1 ; i <= n ;++i)
	{
		for(int j = 1 ; j <= m ; ++j)
		{
			for(int k = 0 ; k < 4 ; ++k)
			{
				int ni = i + dy[k] , nj = j + dx[k] ;
				for( ; che(nj , ni) == 1 ; ni += dy[k] , nj += dx[k])
				{
					if(tab[ni][nj] != '.')
					{
						init[i][j].mov[k] = abs(ni - i) + abs(nj - j) ;
						break ;
					}
				}
				if(che(nj , ni) == 0) init[i][j].mov[k] = INF ;
			}
		}
	}
}*/


void inii(void)
{
	for(int i = 1 ; i <= n ;++i)
	{
		for(int j = 1 ; j <= m ; ++j)
		{
			for(int k = 0 ; k < 4 ; ++k)
			{
				int ni = i + dy[k] , nj = j + dx[k] ;
				for( ; che(nj , ni) == 1 ; ni += dy[k] , nj += dx[k])
				{
					if(tab[ni][nj] != '.')
					{
						lin[i][j].mov[k] = abs(ni - i) + abs(nj - j) ;
						break ;
					}
				}
				if(che(nj , ni) == 0) lin[i][j].mov[k] = INF ;
			}
		}
	}
}

int f(int ny , int nx)
{
	//printf("%d %d\n" , ny , nx) ;
	
	int cnt = 0 ;
	inii() ;
	/*
	for(int i = 1 ; i <= n ; ++i)
		for(int j = 1 ; j <= m ; ++j)
			for(int k = 0 ; k < 4 ; ++k)
				lin[i][j].mov[k] = init[i][j].mov[k] ;*/
	
	//printf("xdd\n") ;
	
	while(che(nx , ny) == 1)
	{
		int q = map(tab[ny][nx]) ;
		int a = nx + dx[q] * lin[ny][nx].mov[q] ;
		int b = ny + dy[q] * lin[ny][nx].mov[q] ;
		
		//printf("sr\n")  ;
		
		for(int k = 0 ; k < 2 ; ++k)
		{
			int kk = (k + 2) % 4 ;
			int t1 = lin[ny][nx].mov[k] ;
			int t2 = lin[ny][nx].mov[kk] ;
			int n1x = nx + dx[k] * t1 , n1y = ny + dy[k] * t1 ;
			int n2x = nx + dx[kk] * t2 , n2y = ny + dy[kk] * t2 ;
			if(che(n1x , n1y) == 1) lin[n1y][n1x].mov[kk] = abs(n1x - n2x) + abs(n1y - n2y) ;
			if(che(n2x , n2y) == 1) lin[n2y][n2x].mov[k] = abs(n1x - n2x) + abs(n1y - n2y) ;
		}
		
		nx = a , ny = b ;
		++cnt ;
		/*
		for(int k = 0 ; k < 4 ; ++k)
		{
			for(int i = 1 ; i <= n ; ++i)
			{
				for(int j = 1 ; j <= m ; ++j)
				{
					printf("%d " , lin[i][j].mov[k]) ;
				}
				puts("") ;
			}
			puts("\n") ;
		}
		system("pause") ;*/
		//printf("%d %d\n" , dx , dy) ;
		//system("pause") ;
	}
	return cnt ;
}

int main(void)
{
	scanf("%d%d" , &n , &m) ;
	for(int i = 1 ; i <= n ; ++i)
	{
		scanf("%s" , tab[i]) ;
		for(int j = m ; j > 0 ; --j) tab[i][j] = tab[i][j - 1] ;
	}
	
	//ini() ;
	
	/*
	for(int k = 0 ; k < 4 ; ++k)
{
	for(int i = 1 ; i <= n ; ++i)
	{
		for(int j = 1 ; j <= m ; ++j)
		{
			printf("%d " , init[i][j].mov[k]) ;
		}
		puts("") ;
	}
	puts("\n") ;
}*/
	
	for(int i = 1 ; i <= n ; ++i)
	{
		for(int j = 1 ; j <= m ; ++j)
		{
			if(tab[i][j] != '.')
			{
				int a = f(i , j) ;
				max = std::max(max , a) ;
			}
			//printf("%d %d\n" , i , j) ;
		}
	}
//	printf("xd\n") ;
	
	for(int i = 1 ; i <= n ; ++i)
	{
		for(int j = 1 ; j <= m ; ++j)
		{
			if(f(i , j) == max) ++cnt ;
		}
	}
	
	printf("%d %d\n" , max , cnt) ;
	/*
	for(int i = 1 ; i <= n ; ++i)
	{
		for(int j = 1 ; j <= m ; ++j)
		{
			printf("%d " , ans[i][j]) ;
		}
		puts("") ;
	}*/
	
	return 0 ;
}
