#include <bits/stdc++.h>

using namespace std;

int h, w;

using ull = unsigned long long;
ull C[65][65];
// int drs[] = {-2, -1, -1, 0, 0, 1, 1, 2};
// int dcs[] = {0, 1, -1, 2, -2, 1, -1, 0};
// int val[] = {1, 2, 2, 1, 1, 2, 2, 1};

int drs[] = {0, 0, 1, -1};
int dcs[] = {1, -1, 0, 0};

// mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

bool ok(int row, int col) {
    return row >= 0 && col >= 0 && row < h && col < w;
}

ull okcnt(int row, int col) {
    ull res = 0;
    // for (int i = 0; i < 8; i++) {
    //     res += val[i] * ok(row + drs[i], col + dcs[i]);
    // }
    for (int i = 0; i < 4; i++) {
        res += ok(row + drs[i], col + dcs[i]);
    }
    return res;
}

ull sumsc(bool parity) {
    ull res = 0;
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            if (parity == ((row + col) & 1)) res += okcnt(row, col);
        }
    }
    return res;
}

double proba(int row, int col) {
    return double(okcnt(row, col)) / sumsc((row + col) & 1);
}

void show(ull state) {
    ull power = 1;
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            cout << ((state & power) ? 'O' : '.');
            power <<= 1;
        }
        cout << endl;
    }
}

// double state_proba(ull state, bool parity) {
//     show(state);
//     ull power = 1;
//     int row, col;
//     ull sum = sumsc(parity);
//     for (row = 0; row < h; row++) {
//         for (col = 0; col < w; col++) {
//             parity = 1 - parity;
//             if (state & power) goto done;
//             power <<= 1;
//         }
//     }
//     if (row == h && col == w) return parity;
// done:
//     return double(okcnt(row, col)) / sum * state_proba(state ^ power, parity);
// }

// int _a = 75, _b = 74, _m = (1 << 16) + 1;
// int seed = 2137;
// int rng() {
//     return seed = (_a * seed + _b) % _m;
// }

// unordered_set<ull> seen;
// ull count_reachable(ull state, bool onestep) {
//     int count = __builtin_popcountl(state);
//     if (!count) return 1;


//     array<ull, 8> positions;
//     array<int, 8> expos;

//     ull power = 1;
//     int expo = 0;
//     int i = 0;
//     for (int row = 0; row < h; row++) {
//         for (int col = 0; col < w; col++) {
//             if (state & power) {
//                 positions[i] = power;
//                 expos[i] = expo;
//                 if (++i == count) goto done;
//             }
//             power <<= 1;
//             expo++;
//         }
//     }
//     // cerr << count << endl;
// done:

//     // array<ull, 32> reachable;
//     if (!onestep) seen = unordered_set<ull>();

//     for (int j = 0; j < count; j++) {
//         expo = expos[j];
//         ull pos = positions[j];
//         if (expo % w) {
//             ull target = pos >> 1;
//             if (!(state & target)) {
//                 // ull new_state = (state ^ pos) | target;
//                 // reachable[reachcnt++] = new_state;
//                 if (onestep) {
//                     seen.insert((state ^ pos) | target);
//                 } else {
//                     count_reachable((state ^ pos) | target, false);
//                 }
//             } 
//         } 
//         if ((expo + 1) % w) {
//             ull target = pos << 1;
//             if (!(state & target)) {
//                 // ull new_state = (state ^ pos) | target;
//                 // reachable[reachcnt++] = new_state;
//                 if (onestep) {
//                     seen.insert((state ^ pos) | target);
//                 } else {
//                     count_reachable((state ^ pos) | target, false);
//                 }
//             } 
//         }
//         if (expo >= w) {
//             ull target = pos >> w;
//             if (!(state & target)) {
//                 // ull new_state = (state ^ pos) | target;
//                 // reachable[reachcnt++] = new_state;
//                 if (onestep) {
//                     seen.insert((state ^ pos) | target);
//                 } else {
//                     count_reachable((state ^ pos) | target, false);
//                 }
//             } 
//         }
//         if (expo < (h - 1) * w) {
//             ull target = pos << w;
//             if (!(state & target)) {
//                 // ull new_state = (state ^ pos) | target;
//                 // reachable[reachcnt++] = new_state;
//                 if (onestep) {
//                     seen.insert((state ^ pos) | target);
//                 } else {
//                     count_reachable((state ^ pos) | target, false);
//                 }
//             } 
//         }
//     }
//     // cerr << reachcnt << endl;
//     // return reachable[rng() % reachcnt];
//     return seen.size();
// }

// // map<ull, double> counts;



void solve() {
    C[0][0] = 1;
    for (int n = 1; n <= 64; ++n) {
        C[n][0] = C[n][n] = 1;
        for (int k = 1; k < n; ++k) {
            C[n][k] = C[n - 1][k - 1] + C[n - 1][k];
        }
    }

    cin >> h >> w;
    ull power = 1;
    ull state = 0;
    bool parity = 1;
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            char c;
            cin >> c;
            if (c == 'O') {
                state |= power;
                parity ^= (row + col) & 1;
            }
            power <<= 1;
        }
    }

    bool old_parity = parity;
    // cout << state << endl;

    ull target_state = 0;
    double tproba = 1;
    power = 1;
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            char c;
            cin >> c;
            if (c == 'O') {
                target_state |= power;
                parity ^= (row + col) & 1;
                tproba *= proba(row, col); 
            }
            power <<= 1;
        }
    }
    // cout << target_state << endl;

    if (!parity) {
        cout << "0" << endl;
        return;
    }

    // ull target_reachable = count_reachable(target_state, true);

    // ull sum_reachable = 0;
    int popcount = __builtin_popcountl(state);
    // if (popcount != __builtin_popcount(target_state)) {
    //     cout << "0" << endl;
    //     return;
    // }
    while (popcount) {
        tproba *= popcount;
        popcount--;
    }
    // cout.precision(16);
    cout << fixed << setprecision(15) << tproba << endl;
    // cout << fixed << setprecision(15) << state_proba(state, old_parity) << endl;


    // array<ull, 64> avail;
    // iota(avail.begin(), avail.end(), 0);
    // int len = w * h;

    // int got = 0;
    // for (got = 0; got < 10000000;) {
    //     shuffle(avail.begin(), avail.begin() + len, rng);
    //     ull random_state = 0;
    //     for (int cnt = 0; cnt < popcount; cnt++) {
    //         random_state |= (ull)1 << avail[cnt];
    //     }
    //     got++;
    //     sum_reachable += count_reachable(random_state, true);
    // }

    // cout << target_reachable << endl;
    // cout << double(sum_reachable) / got << endl;

    // cout << double(target_reachable * got) / sum_reachable / C[h * w][popcount] << endl; 
    //     // for (int i = 0; i < 10; i++) {
    //     state = move(state);
    //     show(state);
    // }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

// #ifdef LOCAL
//     int t; cin >> t; while (t--)
// #endif

    solve();

    cout.flush();
}