/*
ICPC Southeast USA Regional 2008
Problem: Teleport
Author: Yiu Yu Ho

Analysis:
Clearly, if you ever walk some steps then teleport, it is not optimal by any means, 
because a teleportation is memoryless and renders your previous walking useless.  
Thus, if you have decided to walk, you will never teleport again.

So, the only option is to teleport 0 or more times, until you arrive at some square, 
then walk from the square to exit.  What will characterize the set of squares you want to
start walking?  It should be clear that there's really no difference between the square, 
except by the number of steps required (shortest path) to an exit.

Thus, the correct strategy is clear:
(1) Select k
(2) Teleport until you arrive at a cell that requires at most k steps to exit the maze.
(3) Walk to exit.

The only parameter here is k - what is the optimal value of k such that the strategy produces 
optimal solution?
Since the number of steps to leave is discrete, we can try all possible k from 0 to maxD, 
where maxD is the cell on the map with maximum number of steps to reach an exit.
*/

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

public class teleport
{
	public Scanner in=new Scanner(System.in);
	public PrintStream out=System.out;
	
	public int rn,cn;
	public char[][] M;
	public int[] count,sum;
	public int[][] D;
	public Pair me;
	public int maxD,total;
	
	public int oo=987654321;
	
	public DecimalFormat fmt=new DecimalFormat("0.000");

	public void main()
	{
		int i,j,k;
		
		rn=in.nextInt();
		while(rn>0)
		{
			cn=in.nextInt();
			
			M=new char[rn][cn];
			for(i=0;i<rn;++i) M[i]=in.next().toCharArray();
			
			D=new int[rn][cn];
			calD();
			
			maxD=0;
			for(i=0;i<rn;++i)
			for(j=0;j<cn;++j)
			if(-oo<D[i][j] && D[i][j]<oo)
			{
				maxD=Math.max(maxD,D[i][j]);
			}
			
			count=new int[maxD+1];
			total=0;
			
			for(i=0;i<rn;++i)
			for(j=0;j<cn;++j)
			{
				if(-oo<D[i][j] && D[i][j]<oo)
				{
					++count[D[i][j]];
				}
				if(-oo<D[i][j])
				{
					++total;
				}
			}
			
			sum=new int[maxD+1];
			sum[0]=count[0];
			for(i=1;i<=maxD;++i) sum[i]=sum[i-1]+count[i];
			
			double res=D[me.x][me.y];
			double p,A;
			
			A=0;
			for(k=0;k<=maxD;++k)
			{
				p=(double)sum[k]/total;
				A+=k*count[k];
				res=Math.min(res,1/p+A/sum[k]);
			}
			
			out.println(fmt.format(res+1e-12));
						
			rn=in.nextInt();
		}//end while rn>0
	}
		
	public void calD()
	{
		int i,j,k;
		ArrayList<Pair> Q=new ArrayList<Pair>();
		
		for(i=0;i<rn;++i)
		for(j=0;j<cn;++j)
		{
			if(M[i][j]=='E') 
			{
				D[i][j]=0;
				Q.add(new Pair(i,j));
			}
			else if(M[i][j]=='X') D[i][j]=-oo;
			else if(M[i][j]=='.' || M[i][j]=='Y')
			{
				D[i][j]=oo;
				if(M[i][j]=='Y') 
				{
					me=new Pair(i,j);
				}
			}
			else
			{
				System.err.println("Bad Judge Data.");
			}
		}
		
		Pair p;
		int h=0;
		int x,y;
		
		while(h<Q.size())
		{
			p=Q.get(h);
			++h;
			
			for(k=0;k<4;++k)
			{
				x=p.x+dx[k]; y=p.y+dy[k];
				if(valid(x,y) && D[x][y]>D[p.x][p.y]+1)
				{
					D[x][y]=D[p.x][p.y]+1;
					Q.add(new Pair(x,y));
				}
			}
		}
	}
	
	public boolean valid(int x,int y) { return 0<=x && x<rn && 0<=y && y<cn; }
	
	public int[] dx={0,0,1,-1};
	public int[] dy={1,-1,0,0};
	
	private class Pair
	{
		public int x,y;
		public Pair(int xx,int yy) { x=xx; y=yy; }
	}
	
	public static void main(String[] args)
	{
		long start=System.currentTimeMillis();		
		(new teleport()).main();
		System.err.println("Time Spent = "+(System.currentTimeMillis()-start)+"ms");
	}
}