#include <bits/stdc++.h>

constexpr int D = 4;
constexpr int DX[]{1, -1, 0, 0};
constexpr int DY[]{0, 0, 1, -1};

std::mt19937 rng(std::random_device{}());

int main() {
    int n, m;
    std::cin >> n >> m;

    std::vector<std::string> map(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> map[i];
    }

    auto get = [&](int x, int y) -> int  {
        return x * m + y;
    };

    std::vector<std::vector<int>> adj(n * m);
    for (int x = 0; x < n; ++x) {
        for (int y = 0; y < m; ++y) {
            if (map[x][y] == '#') {
                continue;
            }
            for (int d = 0; d < D; ++d) {
                int nx = x + DX[d], ny = y + DY[d];
                if (nx >= 0 && nx < n && ny >= 0 && ny < m && map[nx][ny] != '#') {
                    int u = get(x, y), v = get(nx, ny);
                    adj[u].push_back(v);
                    adj[v].push_back(u);
                }
            }            
        }
    }

    auto randomize = [&]() {
        for (auto &vec : adj) {
            std::shuffle(vec.begin(), vec.end(), rng);
        }
    };
    
    auto check = [&](int root) -> int {
        std::vector<int> st;
        st.push_back(root);

        std::vector<uint8_t> vist(n * m);
        vist[root] = true;

        auto hasadj = [&](int x) {
            for (int to : adj[x]) {
                if (!vist[to]) {
                    return true;
                }
            }
            return false;
        };

        bool win = true;        
        while (true) {
            while (hasadj(st.back())) {
                int next = -1;
                for (int to : adj[st.back()]) {
                    if (!vist[to]) {
                        next = to;
                        break;
                    }
                }
                assert(next != -1);

                st.push_back(next);
                vist[next] = true;
            }
            win = st.size() & 1;
            while (st.size() > 2) {
                st.pop_back();
                st.pop_back();
                if (!st.empty() && hasadj(st.back())) {
                    break;
                }
            }
            if (st.empty() || !hasadj(st.back())) {
                break;
            }
        }

        return win;
    };

    int ans = 0;
    for (int x = 0; x < n; ++x) {
        for (int y = 0; y < m; ++y) {
            if (map[x][y] == '#') {
                continue;
            }
            bool flag = true;
            for (int _ = 0; _ < 100; ++_) {
                randomize();
                if (!check(get(x, y))) {
                    flag = false;
                    break;
                }
            }
            ans += flag;
        }
    }

    std::cout << ans << '\n';
}