#include "bits/stdc++.h"
using namespace std;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define all(x) x.begin(),x.end()
#define sz(x) int(x.size())
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;

const int sss[] = {0,40000,40000,20000,12000,80000,8000,6000,5000,5000,4000,4000,4000,4000,4000,4000,4000,4000,4000};

const short oo = 1000;

struct segtree {
    int n,ptwo=1;
    struct U { // updates: 
        short a=0; // identity update
        void operator+=(U u) { a += u.a; } // stack update on another, U u is the newer update.
    };
    struct V {
        int minpos;
        short mini = oo;
        V upd(U u) const { return {
            minpos,
            mini + u.a
        }; } // effect of update on V
        V operator+(V o) const { 
            // assert(minpos < o.minpos);
            return (mini < o.mini) ? *this : o;
        } // merge two values
    };
    struct node { 
        V v; U u;
        V getv() { return v.upd(u); }
    };
    vector<node> seg;
    segtree(){}
    segtree(int nn) : n(nn) {
        while(ptwo<n) ptwo*=2;
        seg.assign(ptwo*2,{});
    }
    void push(int i) {
        U u = seg[i].u;
        seg[i].v = seg[i].v.upd(u);
        seg[i*2].u+=u, seg[i*2+1].u+=u;
        seg[i].u = {};
    }
    void pull(int i) { seg[i].v = seg[i*2].getv() + seg[i*2+1].getv(); }
    void upd(int i, int l, int r, int ql ,int qr, U u) {
        if(qr<=l or r<=ql) return;
        if(ql<=l and r<=qr) return void(seg[i].u+=u);
        int mid = (l+r)/2;
        push(i);
        upd(i*2,l,mid,ql,qr,u);
        upd(i*2+1,mid,r,ql,qr,u);
        pull(i);
    }
    V gt(int i, int l, int r, int ql, int qr) {
        if(qr<=l or r<=ql) return {};
        if(ql<=l and r<=qr) return seg[i].getv();
        int mid = (l+r)/2;
        push(i);
        return gt(i*2,l,mid,ql,qr)+gt(i*2+1,mid,r,ql,qr);
    }
    void update(int l, int r, short u) { upd(1,0,ptwo,l,r,{u}); } // [l,r)
    V get(int l, int r) {return gt(1,0,ptwo,l,r); } // [l,r)
    void build() { for(int i=ptwo-1;i>=1;--i) pull(i); }
    node& operator[](int i) {return seg[i+ptwo];}
};

mt19937 rng;

decltype(chrono::high_resolution_clock::now()) t1;

void cmax(int& a, int b){
    a = max(a,b);
}

struct frac{
    int a,b;
    bool operator<(const frac& B) const {
        return a*B.b < b*B.a;
    };

    void operator/=(int n){
        a/=n,b/=n;
    }
    void reduce(){
        int g = gcd(a,b);
        (*this)/=g;
    }
    void print(){
        cout << a << '/' << b << '\n';
    }
    // first fraction <= a/b with denom d
    int lb(int d){
        int x = (a*d)/b;
        return x;
    }
    // first fraction < a/b with denom d
    int ub(int d){
        int x = (a*d - 1) / b;
        return x;
    }
};

int rnd(int l, int r){
    return uniform_int_distribution(l,r)(rng);
}

void solve(){
    int n,l; cin >> n >> l;
    vi realord(n);
    iota(all(realord),0);

    vector<string> A(n);
    for(auto& c : A) {
        rep(i,0,l) {
            char d; cin >> d;
            c += d;
        }
    }
    t1 = chrono::high_resolution_clock::now();
    // if (print) sleep(100);

    // check if impossible
    rep(i,0,l){
        bool bad = 1;
        rep(j,0,n) if (A[j][i] == '.'){
            bad = 0;
            break;
        }
        if (bad){
            cout << "-1\n";
            return;
        }
    }

    // always possible


    // calculate sums
    vector<short> sums(l);
    rep(i,0,l) rep(j,0,n) sums[i] += A[j][i] == '.';

    // get list of empty (halfopen) intervals
    vector<vector<array<int,2>>> segs(n);
    rep(i,0,n){
        for(int j = 0; j < l; ++j) if (A[i][j] == '.' and sums[j] > 1){
            int to = j;
            while(to<l and A[i][to] == '.' and sums[to] > 1) to++;
            segs[i].push_back({j,to});
            j = to-1;
        }

        if (segs[i].empty()){
            cout << "0/1\n";
            return;
        }
    }
    
    shuffle(all(realord),rng);
    // 
    
    vi printans;
    frac ans = {0,1}, upperbound = {l,1};
    
    rep(tries,0,1){
        ans = {0,1}, upperbound = {l,1};

        rep(b,1,n+1){
            // build segtree
            segtree seg(b*l);
            rep(i,0,l){
                rep(j,0,b) seg[i*b + j].v = {i*b+j, sums[i]};
            }
            seg.build();
    
            // list of interesting points
            vector<vector<int>> pts(n);
            rep(i,0,n) pts[i].reserve(b*l);
    
            // helper functions
    
            auto build = [&](vi ord, int a) -> vi {
                vi bad;
                vi ops;
    
                int lb = 0;
                for(auto i : ord){
                    auto it = lower_bound(all(pts[i]),lb);
                    if (it == end(pts[i])){
                        bad.push_back(i);
                    }else{
                        int at = *it;
                        ops.push_back(at);
                        seg.update(at,at+a,-1);
                        auto ret = seg.get(at,at+a);
                        lb = max(lb, at);
                        if (ret.mini == 1){
                            lb = max(lb, ret.minpos+1);
                        }
                    }
                }
    
                // undo operations
                for(auto at : ops){
                    seg.update(at,at+a,1);
                }
    
                return bad;
            };
            
            const int iters = (b<8 ? 10000 : (b<14?8000:6000));

            auto simAn = [&](int a) -> bool {
                vi ord = realord;
    
                rep(iter,0,iters){
                    auto bad = build(ord,a);
                    if (bad.empty()) {
                        realord = ord;
                        return true;
                    }
    
                    // make swaps
                    int pos = find(all(ord),bad[0])-begin(ord);
                    if (pos == 0) return false;
                    swap(ord[rnd(0,pos-1)],ord[pos]);
    
                    // try random swap
                    {
                        int x = rnd(0,n-1), y = rnd(0,n-1);
                        swap(ord[x],ord[y]);
                        auto ret = build(ord,a);
                        if (!(sz(ret) < sz(bad))) {
                            swap(ord[x], ord[y]);
                        }
                    }
                }
    
                return false;
            };
            
            auto makePts = [&](int a) -> void {
                rep(i,0,n) pts[i].clear();
                rep(i,0,n){
                    for(auto [L,R] : segs[i]){
                        int diff = (R-L)*b;
                        for(int s = L*b; s + a <= R*b; ++s){
                            pts[i].push_back(s);
                        }
                    }
                }
            };

            // bin search on answer
            int lo = ans.lb(b), hi = upperbound.ub(b);
            while(lo<hi){
                int a = (lo+hi+1)/2;
    
                // get list of points for a
                makePts(a);
    
                // try filling
                bool good = simAn(a);
                if (good){
                    lo = a;
                }else{
                    hi = a-1;
                }
            }
    
            // update search range
            if (ans < frac{lo,b}){
                ans = frac{lo,b};
            }
            if (frac{lo+1,b} < upperbound){
                upperbound = {lo+1,b};
            }
        }
    }

    shuffle(all(realord),rng);

    for (int b = min(3,n+1); b>0; --b){
        segtree seg(b*l);
        rep(i,0,l){
            rep(j,0,b) seg[i*b + j].v = {i*b+j, sums[i]};
        }
        seg.build();

        // list of interesting points
        vector<vector<int>> pts(n);
        rep(i,0,n) pts[i].reserve(b*l);

        auto build = [&](vi ord, int a) -> vi {
            vi bad;
            vi ops;

            int lb = 0;
            for(auto i : ord){
                auto it = lower_bound(all(pts[i]),lb);
                if (it == end(pts[i])){
                    bad.push_back(i);
                }else{
                    int at = *it;
                    ops.push_back(at);
                    seg.update(at,at+a,-1);
                    auto ret = seg.get(at,at+a);
                    lb = max(lb, at);
                    if (ret.mini == 1){
                        lb = max(lb, ret.minpos+1);
                    }
                }
            }

            // undo operations
            for(auto at : ops){
                seg.update(at,at+a,1);
            }

            return bad;
        };


        auto simAn = [&](int a, int iters = 20000) -> bool {
            vi ord = realord;

            rep(iter,0,iters){
                auto bad = build(ord,a);
                if (bad.empty()) {
                    realord = ord;
                    return true;
                }

                // make swaps
                int pos = find(all(ord),bad[0])-begin(ord);
                if (pos == 0) return false;
                swap(ord[rnd(0,pos-1)],ord[pos]);

                // try random swap
                {
                    int x = rnd(0,n-1), y = rnd(0,n-1);
                    swap(ord[x],ord[y]);
                    auto ret = build(ord,a);
                    if (!(sz(ret) < sz(bad))) {
                        swap(ord[x], ord[y]);
                    }
                }
            }

            return false;
        };
        
        auto makePts = [&](int a) -> void {
            rep(i,0,n) pts[i].clear();
            rep(i,0,n){
                for(auto [L,R] : segs[i]){
                    int diff = (R-L)*b;
                    for(int s = L*b; s + a <= R*b; ++s){
                        pts[i].push_back(s);
                    }
                }
            }
        };

        while(true){
            shuffle(all(realord),rng);
            int a = ans.lb(b) + 1;
            makePts(a);
            if (simAn(a, sss[b])){
                ans = {a,b};
            }else break;
        }

        if (b==1){
            auto t2 = chrono::high_resolution_clock::now();
            int elapsed = chrono::duration_cast<chrono::milliseconds>(t2-t1).count();
            int a = ans.lb(b) + 1;
            while(elapsed < 4000){
                shuffle(all(realord),rng);
                
                if (simAn(a, sss[b])){
                    ans = {a,b};
                    break;
                }
                t2 = chrono::high_resolution_clock::now();
                elapsed = chrono::duration_cast<chrono::milliseconds>(t2-t1).count();
            }
        }
    }
    
    // answer print
    ans.reduce();
    ans.print();
}

int main(){
    cin.tie(NULL),cin.sync_with_stdio(false);
    auto seed = chrono::steady_clock::now().time_since_epoch().count();
    rng.seed(seed);

    solve();
}

/*

18 29
.....................X.......
...........X.................
.....X.......................
........................X....
.............................
......................X......
...X.........................
.........................X...
......X......................
.............................
.............................
.......X.....................
X............................
...X.........................
.............................
.............................
.............................
........X....................


4 53
X.......................................X.....X......
.....................................................
...................................X.......X.........
...........X.X.......................................


18 29
.XXXX.X.XXXXX.XXXXX.....XXX.X
XX...XXX..XXXXXXXXX.X.XXXXX.X
X.XX..XX..XX.XXXXXXXXXXXX.XX.
XXX..XX...XXXXX..X....XXXX.XX
XX..XX.XXX...XX.X....XXX.XXXX
XXX.XXX.XXXX.XXXX....X.XX...X
XXXX.X.XXXX.XXX.X..XXX...X.X.
XXXX.X..XX.X.XXX.XXXXX..XX..X
XXXXXXXXXXXX..X...XXXXXXXXXX.
XX...XXXXX...XX.XXX.XX.XXXXXX
X.XX.X.XXXX.XX.X...XXXXXX.XXX
.....X.XXX..XX..XXXXX.XXXX.XX
X.XXXXX.XX.X...XXXX.X.X.X.X.X
X.XXX.X...XX.X.XXXXXXX.XXXX..
XXX....XXXX.X..XXXXXXXX.XX.X.
XXX.XX..XXX.XXXXXXX.X.XXXXXXX
.X.XX...X.XXXXXXXXX..X.X..XXX
XXXXXX.X.XX..X.XX.X.X.XXXXX.X

17 14
XXXXXXXXXX.XX.
XXXXXX.XXXXXXX
.X.X.XXXXXX.XX
X.XXX.XX..XX.X
XXXXX.XXXXXXXX
XXXXXXX.XXXXXX
XXX.XXX.XXXXXX
XX..XXXXXXX.XX
XX.XXXXX.X.XXX
XXXXX.XXXXX...
XXXXXX.XXXX.XX
XXXXXX.XXXXXXX
XXXX.XXX.XXXXX
XXXXXX..X.XXXX
XX.XXXXXX.XXXX
.XXXX.X.XXXXXX
X.XXXXXXXXXXXX
*/