#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;

void solve() {
    int n, L;
    std::cin >> n >> L;
    
    std::vector<std::string> s(n);
    for (int i = 0; i < n; i++) {
        std::cin >> s[i];
    }
    
    std::vector<int> col(L);
    for (int t = 0; t < L; t++) {
        for (int i = 0; i < n; i++) {
            col[t] += s[i][t] == '.';
        }
        if (col[t] == 0) {
            std::cout << -1 << "\n";
            return;
        }
    }
    
    std::vector len(n, std::vector<int>(L + 1)), nxt(n, std::vector<int>(L + 1)), pre(n, std::vector<int>(L + 1));
    auto check = [&](int num, int den) {
        assert(num > 0);
        
        for (int i = 0; i < n; i++) {
            for (int j = L - 1; j >= 0; j--) {
                len[i][j] = (s[i][j] == '.' && col[j] > 1) ? 1 + len[i][j + 1] : 0;
            }
            nxt[i][L] = -1;
            for (int j = L - 1; j >= 0; j--) {
                nxt[i][j] = len[i][j] * den >= num ? j : nxt[i][j + 1];
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 1; j <= L; j++) {
                pre[i][j] = col[j - 1] == i + 1 ? j : pre[i][j - 1];
            }
        }
        
        bool ok = false;
        std::vector<int> seg;
        auto dfs = [&](auto &&self, int mask) {
            if (ok || mask == (1 << n) - 1) {
                ok = true;
                return;
            }
            
            std::array<std::array<int, 2>, 2> option {L * den, -1, L * den, -1};
            int cnt = __builtin_popcount(mask);
            
            for (int i = 0; i < n; i++) {
                if (mask >> i & 1) {
                    continue;
                }
                
                int pos = seg.empty() ? 0 : seg.back();
                
                int l = pos;
                int c = cnt;
                for (auto r : seg) {
                    r += num;
                    if (r > l) {
                        int p = std::min(r, pre[c][(r + den - 1) / den] * den);
                        pos = std::max(pos, p);
                        l = r;
                    }
                    c--;
                }
                
                if (len[i][pos / den] * den - pos % den < num) {
                    pos = nxt[i][(pos + den - 1) / den];
                    if (pos == -1) {
                        continue;
                    }
                    pos *= den;
                }
                
                std::array<int, 2> v {pos, i};
                if (v < option[0]) {
                    option[1] = option[0];
                    option[0] = v;
                } else if (v < option[1]) {
                    option[1] = v;
                }
            }
            
            for (auto [pos, i] : option) {
                if (i == -1) {
                    continue;
                }
                seg.push_back(pos);
                self(self, mask | 1 << i);
                seg.pop_back();
            }
        };
        dfs(dfs, 0);
        
        return ok;
    };
    
    std::vector<std::array<int, 2>> fracs;
    for (int i = 0; i <= L; i++) {
        for (int j = 1; j <= n; j++) {
            if (std::gcd(i, j) == 1) {
                fracs.push_back({i, j});
            }
        }
    }
    
    std::sort(fracs.begin(), fracs.end(),
        [&](auto a, auto b) {
            return 1LL * a[0] * b[1] < 1LL * a[1] * b[0];
        });
    
    int lo = 0, hi = fracs.size() - 1;
    while (lo < hi) {
        int x = (lo + hi + 1) / 2;
        if (check(fracs[x][0], fracs[x][1])) {
            lo = x;
        } else {
            hi = x - 1;
        }
    }
    auto [num, den] = fracs[lo];
    std::cout << num << "/" << den << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int t = 1;
    // std::cin >> t;
    
    for (int i = 1; i <= t; i++) {
        // std::cerr << "test " << i << "\n";
        solve();
    }
    
    return 0;
}