/*
    題意：n,m的網格，有一些static particles，規定任意兩個不能在同一行、列，不能在相鄰的對角線
     A dynamic particle選擇非static的cell作為起點和終點，然后從起點選擇最短路徑走到終點（不經過
     static particles）。問平均路長

     參見解題報告：http://www.codeforces.com/blog/entry/1171
    題目的那種規定，發現，對于同一行、列，如果要跨過那個'X'，就需要多加2
    而對于連續行的'X'，如下圖：
    1..X..
    2.X
    3X.
    1的左邊到1、2、3的右邊需要多加2
    2的左邊到2、3的右邊也需要多加2
    
    另外，對于下圖：
    1..X..    
    2X.
    3.X
    1的左邊到2的右邊需多加2，而到3的右邊不需加
    2的右邊到3的左邊需多加2
    所以，從上往下，對于連續的行，尋找遞增或遞減的一塊，然后對于這一連續的塊，統計從左邊到右邊
    或右邊到左邊需要多加的步數2
    
    解題報告的框架，兩兩點距離之和（包括'X'）- 'X'到所有點距離和*2 + 'X'到'X'距離和*2
                                                                          這里多減了2倍'X'到'X'的，所以要加上
     最后，再加上因為'X'存在要繞路需要多加的距離
*/

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>

using namespace std;

const int MAXN = 1011;

char field[MAXN][MAXN];
int row[MAXN] , col[MAXN];

__int64 solve(int n , int m , int row[])//逐行掃，尋找連續的塊
{
        __int64 ans = 0 , i;
        for(i = 1 ; i <= n ; i++)
        {               
                if(row[i] == -1)continue;

                int last = 0 , start = i , end;
                while(i<=n && row[i] !=-1 && row[i] > last)
                {
                        last = row[i];
                        i++;
                }
                end = --i;
                for(int f = start ; f <= end; f++)
                        for(int s = f ; s <= end; s++)
                                ans += 2*(f==s?1:2)*(row[f]-1)*(m-row[s]);              
        }

        for(i = 1 ; i <= n ; i++)
        {               
                if(row[i] == -1)continue;

                int last = m + 1 , start = i , end;
                while(i<=n && row[i] !=-1 && row[i] < last)
                {
                        last = row[i];
                        i++;
                }
                end = --i;
                for(int f = start ; f <= end; f++)
                    for(int s = f ; s <= end; s++)
                        ans += 2*(f==s?1:2)*(m-row[f])*(row[s]-1);                    
        }
        return ans;
}

int main()
{
        for(int n,m; ~scanf("%d%d",&n,&m); )
        {
                int i,j , num = n*m;
                for(i = 1 ; i <= n ; i ++)
                        scanf("%s",field[i]+1);

                vector<pair<int,int> > vt ;
                vector<pair<int,int> >::iterator it , _it;
                memset(row,-1,sizeof(row));
                memset(col,-1,sizeof(col));
                for(i = 1 ; i <= n ; i++)
                        for(j = 1 ; j <= m ; j++)                       
                                if(field[i][j] == 'X')
                                {
                                        row[i] = j;
                                        col[j] = i;
                                        vt.push_back(make_pair(i,j));
                                        num--;
                                }

                __int64 ans = 0;//要用長整，不然會損失精度
                for(i = 1 ; i <= n; i ++)
                        ans += (__int64)m*m*i*(i-1);
                for(j = 1 ; j <= m ; j++)
                        ans +=  (__int64)n*n*j*(j-1);
                
                for(i = 1 ; i <= n;  i++)
                        for(it = vt.begin() ; it != vt.end();  it++)
                        {
                                ans -= 2*m*abs(i-it->first);
                        }
                for(j = 1 ; j<= m;  j++)
                        for(it = vt.begin() ; it != vt.end();  it++)
                        {
                                ans -= 2*n*abs(j-it->second);
                        }
                for(it = vt.begin(); it != vt.end() ; it++)
                        for(_it = vt.begin() ; _it != vt.end() ; _it++)
                                ans += abs(it->first - _it->first) + abs(it->second - _it->second);
                
                ans += solve(n,m,row);
                //交換行、列
                for(i = 1 ; i <= n ; i ++)
                        for(j = i+1 ; j <= m ; j++)
                                swap(field[i][j] , field[j][i]);
                ans += solve(m,n,col);

                printf("%.10f\n",(double)ans/num/num);
        }
        return 0;
}