// Arup Guha
// 11/11/2022
// Solution to 2021 WF Problem: Where Am I?

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

public class l {

	// Dimensions of grid.
	public static int n;
	public static int x;
	public static int y;
	
	public static ArrayList<int[]> pts;
	
	public static void main(String[] args) throws Exception {
	
		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer tok = new StringTokenizer(stdin.readLine());
		x = Integer.parseInt(tok.nextToken());
		y = Integer.parseInt(tok.nextToken());
		
		pts = new ArrayList<int[]>();
		
		// Read through the y rows.
		for (int i=0; i<y; i++) {
		
			// Go through this row adding each point of interest.
			char[] tmp = stdin.readLine().toCharArray();
			for (int j=0; j<x; j++)
				if (tmp[j] == 'X')
					pts.add(new int[]{j, i});
		}
		
		// # of pts.
		n = pts.size();
		
		// Get all sequences.
		seq[] all = new seq[x*y];
		for (int i=0; i<x*y; i++) 
			all[i] = getSeq(i%x, i/x);
		
		// Sort in lexicographical order.
		Arrays.sort(all);
	
		// Get each difference.
		long tot = 0;
		long[] diff = new long[x*y];
		for (int i=0; i<x*y; i++) {
			long tmp1 = i > 0 ?     all[i].whenDiff(all[i-1]) : 0;
			long tmp2 = i < x*y-1 ? all[i].whenDiff(all[i+1]) : 0;
			diff[i] = Math.max(tmp1, tmp2);
			tot += diff[i];
		}
		
		// Expected Value.
		System.out.println((tot*1.0)/(x*y));
		
		// Max Difference.
		long maxD = 0;
		for (int i=0; i<x*y; i++) maxD = Math.max(diff[i], maxD);
		System.out.println(maxD);
		
		// Get all spots and sort.
		ArrayList<Integer> spots = new ArrayList<Integer>();
		for (int i=0; i<x*y; i++) if (diff[i] == maxD) spots.add(1000*all[i].y + all[i].x);
		Collections.sort(spots);
		
		// Print spots.
		for (int i=0; i<spots.size(); i++) {
			int item = spots.get(i);
			System.out.print("("+(item%1000)+","+(item/1000)+")");
			if (i<spots.size()-1) System.out.print(" ");
		}
		System.out.println();
	}
	
	// Returns the number order of (dx, dy). Note my +y goes down not up.
	public static int getRank(int dx, int dy) {	
		int w = Math.max(Math.abs(dx), Math.abs(dy));
		if (w == 0) return 0;
		if (dx == w)       return 2*w*(2*w-1) + dy + w;
		else if (dy == w)  return (2*w)*(2*w) + w - dx;
		else if (dx == -w) return (2*w)*(2*w)+2*w + w - dy;
		else               return (2*w-1)*(2*w-1) + dx + w - 1;
	}
	
	// Returns the corresponding sequence object if we start at (myx, myy)
	public static seq getSeq(int myx, int myy) {
	
		// Just get the rank of each X and store in array.
		int i = 0;
		int[] res = new int[n];
		for (int[] pt: pts) {
			int dx = pt[0] - myx;
			int dy = pt[1] - myy;
			res[i++] = getRank(dx, dy);
		}
		
		return new seq(res, myx+1, y-myy);
	}
}

class seq implements Comparable<seq> {

	public int[] nums;
	public int x;
	public int y;
	
	public seq(int[] arr, int myx, int myy) {
		Arrays.sort(arr);
		nums = new int[arr.length];
		for (int i=0; i<arr.length; i++) nums[i] = arr[i];
		x = myx;
		y = myy;
	}
	
	// Does lexicographical comparison.
	public int compareTo(seq other) {
		for (int i=0; i<nums.length; i++)
			if (nums[i] != other.nums[i])
				return nums[i] - other.nums[i];
		return 0;
	}
	
	// Returns when we can differentiate this seq from other.
	public int whenDiff(seq other) {
		for (int i=0; i<nums.length; i++) 
			if (nums[i] != other.nums[i]) 
				return Math.min(nums[i],other.nums[i]);		
		return 100; // should never get here.
	}
}