#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);
                }
            }            
        }
    }

    for (auto &vec : adj) {
        std::shuffle(vec.begin(), vec.end(), rng);
    }

    std::vector<uint8_t> vist(n * m);
    std::vector<int> dep(n * m), dp(n * m);
    auto dfs = [&](auto self, int node) -> int {
        vist[node] = true;

        int res = 0;
        for (int to : adj[node]) {
            if (vist[to]) {
                if (dep[to] > dep[node]) {
                    res |= dp[to];
                }
                continue;
            }
            dep[to] = dep[node] + 1;
            res |= self(self, to);
        }
        return dp[node] = !res;
    };

    int ans = 0;
    for (int x = 0; x < n; ++x) {
        for (int y = 0; y < m; ++y) {
            if (map[x][y] == '#') {
                continue;
            }
            std::fill(vist.begin(), vist.end(), false);
            ans += dfs(dfs, get(x, y));
        }
    }

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