#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << (x) << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){
	return o<<"("<<p.fs<<","<<p.sc<<")";
}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){
	o<<"{";
	for(const T& v:vc) o<<v<<",";
	o<<"}";
	return o;
}
using ll = long long;
template<class T> using V = vector<T>;
template<class T> using VV = vector<vector<T>>;
struct MaxMatching{
	int N;
	VV<int> G;

	V<int> mate;

	void add_edge(int a,int b){
		if(a == b) return;
		G[a].pb(b);
		G[b].pb(a);
	}

	MaxMatching(int _N):N(_N),G(N){}

	using P = pair<int,int>;

	int maxMatching(){
		mate = V<int>(N+1,N);
		V<int> first(N+1,N),que(N);
		V<P> label(N+1,P(-1,-1));
		int qh = 0, qt = 0;

		auto enqueue = [&](int v){
			que[qt++] = v;
		};
		auto dequeue = [&](){
			return que[qh++];
		};

		function<void(int,int)> rematch = [&](int a, int b){
			int c = mate[a];
			mate[a] = b;
			if(mate[c] != a) return;
			if(label[a].sc == -1){
				mate[c] = label[a].fs;
				rematch(mate[c],c);
			}else{
				int x,y;
				tie(x,y) = label[a];
				rematch(x,y);
				rematch(y,x);
			}
		};
		auto relabel = [&](int a, int b){
			function<int(int)> findFirst = [&](int v){
				if(label[first[v]].fs < 0) return first[v];
				return first[v] = findFirst(first[v]);
			};
			int x = findFirst(a), y = findFirst(b);
			if(x == y) return;
			P h(~a,b);
			label[x] = label[y] = h;
			int join = -1;
			while(true){
				if(y != N) swap(x,y);
				x = findFirst(label[mate[x]].fs);
				if(label[x] == h){
					join = x;
					break;
				}else{
					label[x] = h;
				}
			}
			for(int v: {first[a],first[b]}){
				for(;v != join; v = first[label[mate[v]].fs]){
					label[v] = P(a,b);
					first[v] = join;
					enqueue(v);
				}
			}
		};
		auto augment = [&](int s){
			label[s] = P(N,-1);
			first[s] = N;
			qh = qt = 0;
			enqueue(s);
			while(qh != qt){
				int a = dequeue();
				for(int b: G[a]){
					if(mate[b] == N && b != s){
						mate[b] = a;
						rematch(a,b);
						return true;
					}else if(label[b].fs >= 0){
						relabel(a,b);
					}else if(label[mate[b]].fs == -1){
						label[mate[b]].fs = a;
						first[mate[b]] = b;
						enqueue(mate[b]);
					}
				}
			}
			return false;
		};

		int numMatch = 0;
		rep(v,N){
			if(mate[v]<N || !augment(v)) continue;
			numMatch++;
			rep(i,qt){		// including popped !!
				int v = que[i];
				label[v] = label[mate[v]] = P(-1,-1);
			}
			label[N] = P(-1,-1);
		}
		mate.pop_back();
		rep(i,N) if(mate[i] == N) mate[i] = -1;
		return numMatch;
	}
};
int solve(){
	using P = pair<int,int>;
	int H,W; cin >> H >> W;
	V<string> s(H); rep(i,H) cin >> s[i];
	int N = H*W;
	// int N,M;
	// cin >> N >> M;
	// V<P> es;
	// rep(i,M){
	// 	int x,y;
	// 	cin >> x >> y;
	// 	x--,y--;
	// 	es.pb(P(x,y));
	// }
	V<P> es;
	rep(i,H) rep(j,W) if(s[i][j] == '.'){
		rep(d,2){
			int ii = i + d, jj = j + (1-d);
			if(ii<H && jj<W && s[ii][jj] == '.'){
				int v = i*W+j, vv = ii*W+jj;
				es.emplace_back(v,vv);
			}
		}
	}

	auto getVal = [&](int v){
		MaxMatching MM(N);
		for(P e: es){
			int x = e.fs, y = e.sc;
			if(v == x || v == y) continue;
			MM.add_edge(x,y);
		}
		return MM.maxMatching();
	};

	int F = getVal(-1);
	int ans = 0;
	rep(i,H) rep(j,W) if(s[i][j] == '.'){
		int v = i*W+j;
		if(F == getVal(v)) ans++;
	}
	return ans;
}
int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout << solve() << endl;
}