#include <bits/stdc++.h>

#pragma GCC optimize("O3, unroll-loops")

using namespace std;

#define len(a) static_cast<int>((a).size())
#define present(c, x) (c.find(x) != c.end())
#define printDecimal(d) std::cout << std::setprecision(d) << std::fixed

using ll = long long;
using ull = unsigned long long;
using ld = long double;
constexpr const int iinf = 1e9 + 7;
constexpr const ll inf = 1e18;
constexpr const ll mod = 1'000'000'007;

template <typename Fun>
class y_combinator_result {
  Fun fun_;

 public:
  template <typename T>
  explicit y_combinator_result(T&& fun) : fun_(std::forward<T>(fun)) {}

  template <typename... Args>
  decltype(auto) operator()(Args&&... args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }
};
template <typename Fun>
decltype(auto) y_combinator(Fun&& fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

struct TrieNode {
  int num_s{0}, weight{0};
  array<int, 2> children{-1, -1};
  pair<int, int> last_start;
};

static constexpr const int dx[] = {-1, 0, 1, 0};
static constexpr const int dy[] = {0, 1, 0, -1};

int n, m;
int grid[100][100];
vector<pair<int, int>> moves[10000];
array<vector<pair<int, int>>, 2> part;

void traverse_grid(int x, int y) {
  int nptr = 0, sz = n * m;
  int top = x, bottom = x, left = y, right = y;
  int pos = x * m + y;
  auto& compressed = moves[pos];
  compressed.emplace_back(grid[x][y], 1);
  for (int num_steps = 1; num_steps < sz;) {
    switch (nptr) {
      case 0: {
        top--;
        for (int i = bottom - 1; i >= top && num_steps < sz; i--) {
          if (i >= 0 && i < n && left >= 0 && left < m) {
            if (compressed.empty() ||
                compressed.back().first != grid[i][left]) {
              compressed.emplace_back(grid[i][left], 1);
            } else {
              compressed.back().second++;
            }
            num_steps++;
          } else {
            if (compressed.empty() || compressed.back().first != 0) {
              compressed.emplace_back(0, 1);
            } else {
              compressed.back().second++;
            }
          }
        }
        break;
      }
      case 1: {
        right++;
        for (int i = left + 1; i <= right && num_steps < sz; i++) {
          if (i >= 0 && i < m && top >= 0 && top < n) {
            if (compressed.empty() || compressed.back().first != grid[top][i]) {
              compressed.emplace_back(grid[top][i], 1);
            } else {
              compressed.back().second++;
            }
            num_steps++;
          } else {
            if (compressed.empty() || compressed.back().first != 0) {
              compressed.emplace_back(0, 1);
            } else {
              compressed.back().second++;
            }
          }
        }
        break;
      }
      case 2: {
        bottom++;
        for (int i = top + 1; i <= bottom && num_steps < sz; i++) {
          if (i >= 0 && i < n && right >= 0 && right < m) {
            if (compressed.empty() ||
                compressed.back().first != grid[i][right]) {
              compressed.emplace_back(grid[i][right], 1);
            } else {
              compressed.back().second++;
            }
            num_steps++;
          } else {
            if (compressed.empty() || compressed.back().first != 0) {
              compressed.emplace_back(0, 1);
            } else {
              compressed.back().second++;
            }
          }
        }
        break;
      }
      case 3: {
        left--;
        for (int i = right - 1; i >= left && num_steps < sz; i--) {
          if (i >= 0 && i < m && bottom >= 0 && bottom < n) {
            if (compressed.empty() ||
                compressed.back().first != grid[bottom][i]) {
              compressed.emplace_back(grid[bottom][i], 1);
            } else {
              compressed.back().second++;
            }
            num_steps++;
          } else {
            if (compressed.empty() || compressed.back().first != 0) {
              compressed.emplace_back(0, 1);
            } else {
              compressed.back().second++;
            }
          }
        }
        break;
      }
      default: {
        assert(false);
      }
    }
    nptr = (nptr + 1) % 4;
  }
}

int main() {
  std::ios_base::sync_with_stdio(false);
  cin.tie(0);
  cin >> m >> n;
  for (int i = 0; i < n; i++) {
    string line;
    cin >> line;
    for (int j = 0; j < m; j++) {
      if (line[j] == 'X') grid[i][j] = 1;
    }
  }
  vector<vector<int>> idx(n, vector<int>(m));
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++) {
      traverse_grid(i, j);
      part[moves[i * m + j][0].first].emplace_back(i, j);
    }
  }
  vector<TrieNode> nodes(1);
  queue<pair<int, array<vector<pair<int, int>>, 2>>> q;
  q.emplace(0, part);
  while (!q.empty()) {
    auto [ptr, curr] = q.front();
    q.pop();
    for (int v = 0; v < 2; v++) {
      if (!curr[v].empty()) {
        array<vector<pair<int, int>>, 2> next;
        nodes.emplace_back();
        nodes[ptr].children[v] = len(nodes) - 1;
        int min_dist = iinf;
        for (const auto& [i, j] : curr[v]) {
          min_dist = min(min_dist, moves[i * m + j][idx[i][j]].second);
        }
        nodes[nodes[ptr].children[v]].weight = min_dist;
        nodes[nodes[ptr].children[v]].num_s = len(curr[v]);
        for (const auto& [i, j] : curr[v]) {
          moves[i * m + j][idx[i][j]].second -= min_dist;
          nodes[nodes[ptr].children[v]].last_start = make_pair(i, j);
          if (moves[i * m + j][idx[i][j]].second == 0) {
            if (++idx[i][j] < len(moves[i * m + j]))
              next[v ^ 1].emplace_back(i, j);
          } else {
            next[v].emplace_back(i, j);
          }
        }
        q.emplace(nodes[ptr].children[v], next);
      }
    }
  }

  int max_depth = 0;
  queue<pair<int, int>> qq;
  qq.emplace(0, 0);
  vector<pair<int, int>> furthest;
  unordered_map<int, int> cnt;
  while (!qq.empty()) {
    auto [curr, depth] = qq.front();
    qq.pop();
    if (nodes[curr].num_s == 1) {
      cnt[depth]++;
      if (max_depth < depth) {
        max_depth = depth;
        furthest = {make_pair(nodes[curr].last_start.second + 1,
                              n - nodes[curr].last_start.first)};
      } else if (max_depth == depth) {
        furthest.emplace_back(nodes[curr].last_start.second + 1,
                              n - nodes[curr].last_start.first);
      }
      continue;
    }
    for (int v = 0; v < 2; v++) {
      if (nodes[curr].children[v] != -1) {
        qq.emplace(nodes[curr].children[v], depth + nodes[curr].weight);
      }
    }
  }

  double e = 0.0;
  for (const auto& [k, v] : cnt) {
    e += double(k * v) / double(n * m);
  }
  printDecimal(3) << e << '\n' << max_depth << '\n';
  sort(furthest.begin(), furthest.end(), [](auto x, auto y) {
    if (x.second != y.second) return x.second < y.second;
    return x.first < y.first;
  });
  for (const auto& [x, y] : furthest) {
    cout << "(" << x << "," << y << ") ";
  }
  cout << '\n';
}