#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>

using namespace std;

typedef unsigned long long ull;


bool parity(vector<pair<int, int>> &tab) {
    int sum = 0;
    for (auto coords: tab) {
        sum += coords.first + coords.second;
    }
    return sum % 2;
}


bool reachable(vector<pair<int, int>> &start, vector<pair<int, int>> &end) {
    if (start.size() != end.size()) {
        return false;
    }
    
    return parity(start) == parity(end);
}

bool isempty(vector<pair<int, int>> &tab, int i, int j) {
    for (auto coord: tab) {
        if (coord.first == i && coord.second == j) {
            return false;
        }
    }
    return true;
}

bool is_in_bounds(int n, int m, int i, int j) {
    return i >= 0 && i < n && j>=0 && j < m;
}

bool valid_one_move(vector<pair<int, int>> &tab, int n, int m, int i, int j) {
    return is_in_bounds(n, m, i, j) && isempty(tab, i, j);
}

int count_one_moves(vector<pair<int, int>> &tab, int n, int m, int i, int j) {
    int count = 0;
    count += valid_one_move(tab, n, m, i+1, j);
    count += valid_one_move(tab, n, m, i-1, j);
    count += valid_one_move(tab, n, m, i, j+1);
    count += valid_one_move(tab, n, m, i, j-1);
    return count;
}

int count_one_pawn_two_moves(vector<pair<int, int>> &tab, int n, int m, pair<int, int> coord) {
    ull moves = 0;
    vector<pair<int, int>> tab_wo_coord = tab;
    tab_wo_coord.erase(remove(tab_wo_coord.begin(), tab_wo_coord.end(), coord), tab_wo_coord.end());
    if (valid_one_move(tab, n, m, coord.first, coord.second+1)) {
        moves += count_one_moves(tab_wo_coord, n, m, coord.first, coord.second+1);
    }
    if (valid_one_move(tab, n, m, coord.first, coord.second-1)) {
        moves += count_one_moves(tab_wo_coord, n, m, coord.first, coord.second-1);
    }
    if (valid_one_move(tab, n, m, coord.first+1, coord.second)) {
        moves += count_one_moves(tab_wo_coord, n, m, coord.first+1, coord.second);
    }
    if (valid_one_move(tab, n, m, coord.first-1, coord.second)) {
        moves += count_one_moves(tab_wo_coord, n, m, coord.first-1, coord.second);
    }
    return moves;
}

ull position_moves(vector<pair<int, int>> &tab, int n, int m) {
    ull moves = 0;
    // one pawn moves twice
    for (auto coord: tab) {
        moves += count_one_moves(tab, n, m, coord.first, coord.second);
    }
    
    return moves;

    // two pawns move once
    for (int i=0; i < tab.size(); i++) {
        //cout << endl << i << endl;
        for (int j=i+1; j < tab.size(); j++) {
            int first_moves = count_one_moves(tab, n, m, tab[i].first, tab[i].second);
            int second_moves = count_one_moves(tab, n, m, tab[j].first, tab[j].second);
            moves += first_moves * second_moves;
                
            // correction for touching pawns
            if (tab[i].first == tab[j].first && abs(tab[i].second-tab[j].second) == 1 ||
                tab[i].second == tab[j].second && abs(tab[i].first-tab[j].first) == 1) {
                moves += first_moves + second_moves;
            }
            
            // correction for distance-2 in-line pawns with empty space in between
            if (tab[i].first == tab[j].first && abs(tab[i].second-tab[j].second) == 2 &&
                isempty(tab, tab[i].first, min(tab[i].second,tab[j].second)+1)) {
                    
                moves--;
            }
            if (tab[i].second == tab[j].second && abs(tab[i].first-tab[j].first) == 2 &&
                isempty(tab, min(tab[i].first,tab[j].first)+1, tab[i].second)) {
                    
                moves--;
            }
            
            // correction for diagonally touching pawns
            if (min(tab[i].first, tab[j].first)+1 == max(tab[i].first, tab[j].first) &&
                min(tab[i].second, tab[j].second)+1 == max(tab[i].second, tab[j].second)) {
                pair<int, int> top_left = make_pair(min(tab[i].first, tab[j].first), min(tab[i].second, tab[j].second));
                
                int pawns_in_square = 0;
                pawns_in_square += !isempty(tab, top_left.first, top_left.second);
                pawns_in_square += !isempty(tab, top_left.first+1, top_left.second);
                pawns_in_square += !isempty(tab, top_left.first, top_left.second+1);
                pawns_in_square += !isempty(tab, top_left.first+1, top_left.second+1);
                
                moves -= 4 - pawns_in_square;
            }
            
            //cout << moves << endl;
        }
    }
    return moves;
}

ull choose(int up, int down) {
    //cout << up << " " << down << " - ";
    if (up < down || down < 0 || up < 0) {
        //cout << 0 <<endl;
        return 0;
    }
    if (down == 0 || up == down) {
        //cout << 1 <<endl;
        return 1;
    }
    
    if (down > up/2) {
        down = up - down;
    }
    ull res = 1;
    for (int i=0; i<down; i++) {
        res *= (up-i);
    }
    for (int i=2; i<=down; i++) {
        res /= i;
    }
    //cout << res <<endl;
    return res;
}

ull select(int x, int even, int odd, bool req_parity) {
    if (x == 0 && req_parity) {
        return 0;
    }
    
    int res = 0;
    for (int i=req_parity; i<=x; i+=2) {
        res += choose(odd, i) * choose(even, x-i);
    }
    return res;
}


// ---- COUNTING ALL MOVES ---- //


int possible_dominos(int n, int m, vector<pair<int, int>> excluded) {
    int count = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            if (!isempty(excluded, i, j)) {
                continue;
            }
            
            count += valid_one_move(excluded, n, m, i+1, j);
            count += valid_one_move(excluded, n, m, i, j+1);
        }
    }
    return count;
}

ull all_moves(int n, int m, int pawns, bool parity) {
    vector<pair<int, int>> empty_board;
    int odd = (n*m)/2;
    int even = n*m-odd;
    
    ull moves = 0;;
    
    // ---- NEW APPROACH
    ull odd_pos_count = 0;
    ull even_pos_count = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            int cnt = count_one_moves(empty_board, n, m, i, j);
            if ((i+j) % 2 == 0) {
                even_pos_count += cnt;
            } else {
                odd_pos_count += cnt;
            }
        }
    }
    moves += select(pawns-1, even-1, odd-1, parity) * even_pos_count;
    moves += select(pawns-1, even-1, odd-1, !parity) * odd_pos_count;
    
    // ----
    return moves;
    
    // back and forth move
    odd_pos_count = 0;
    even_pos_count = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            int cnt = count_one_moves(empty_board, n, m, i, j);
            if ((i+j) % 2 == 0) {
                even_pos_count += cnt;
            } else {
                odd_pos_count += cnt;
            }
        }
    }
    moves += select(pawns-1, even-1, odd-1, parity) * even_pos_count;
    moves += select(pawns-1, even-1, odd-1, !parity) * odd_pos_count;
    
    // move away with single pawn
    odd_pos_count = 0;
    even_pos_count = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            int two = count_one_pawn_two_moves(empty_board, n, m, make_pair(i,j));
            int one = count_one_moves(empty_board, n, m, i, j);
            int cnt = count_one_pawn_two_moves(empty_board, n, m, make_pair(i,j))
                - count_one_moves(empty_board, n, m, i, j);
            if ((i+j) % 2 == 0) {
                even_pos_count += cnt;
            } else {
                odd_pos_count += cnt;
            }
        }
    }
    moves += select(pawns-1, even-2, odd-1, parity) * even_pos_count;
    moves += select(pawns-1, even-1, odd-2, !parity) * odd_pos_count;
    
    
    if (pawns == 1) {
        return moves;
    }

    // move two pawns without interfering
    ull count = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            vector<pair<int, int>> excluded;
            excluded.push_back(make_pair(i, j));
            
            if (is_in_bounds(n, m, i+1, j)) {
                excluded.push_back(make_pair(i+1,j));
                count += possible_dominos(n, m, excluded);
                excluded.pop_back();
            }
            if (is_in_bounds(n, m, i-1, j)) {
                excluded.push_back(make_pair(i-1,j));
                count += possible_dominos(n, m, excluded);
                excluded.pop_back();
            }
            if (is_in_bounds(n, m, i, j+1)) {
                excluded.push_back(make_pair(i,j+1));
                count += possible_dominos(n, m, excluded);
                excluded.pop_back();
            }
            if (is_in_bounds(n, m, i, j-1)) {
                excluded.push_back(make_pair(i,j-1));
                count += possible_dominos(n, m, excluded);
                excluded.pop_back();
            }
        }
    }
    moves += select(pawns-2, even-2, odd-2, parity) * count/2; // second pawn can be on either
    moves += select(pawns-2, even-2, odd-2, !parity) * count/2; // parity of the domino
    
    // second slides in place of the first
    odd_pos_count = 0;
    even_pos_count = 0;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            int free_neigh = count_one_moves(empty_board, n, m, i, j);
            int cnt = free_neigh * (free_neigh-1);
            if ((i+j) % 2 == 0) {
                even_pos_count += cnt;
            } else {
                odd_pos_count += cnt;
            }
        }
    }
    moves += select(pawns-2, even-1, odd-2, !parity) * even_pos_count;
    moves += select(pawns-2, even-2, odd-1, !parity) * odd_pos_count;
    
    return moves;
}


vector<pair<int, int>> load_tab(int n, int m) {
    vector<pair<int, int>> tab;
    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            char val;
            cin >> val;
            if (val == 'O') {
                tab.push_back(make_pair(i,j));
            }
        }
    }
    return tab;
}


int main() {
    int n, m;
    cin >> n >> m;
    
    vector<pair<int, int>> start_tab = load_tab(n, m);
    vector<pair<int, int>> end_tab = load_tab(n, m);
    
    if (!reachable(start_tab, end_tab)) {
        cout << 0;
        return 0;
    }
    
    // cout << choose(8, 5) << endl;
    // cout << select(2, 3, 2, true) << endl;
    
    // vector<pair<int, int>> excl;
    // excl.push_back(make_pair(1,1));
    // excl.push_back(make_pair(2,2));
    // excl.push_back(make_pair(1,2));
    // excl.push_back(make_pair(2,1));
    // cout << possible_dominos(100, 100, excl) << endl << endl;
    
    std::cout << std::fixed;
    std::cout << std::setprecision(15);
    long double pos_mvs = position_moves(end_tab, n, m);
    long double all_mvs = all_moves(n, m, end_tab.size(), parity(end_tab));
    // cout << parity(end_tab) << endl;
    // cout << (ull) pos_mvs << endl;
    // cout << (ull) all_mvs << endl;
    pos_mvs /= all_mvs;
    cout << pos_mvs << endl;
    return 0;
}