#include <bits/stdc++.h>

using namespace std;

namespace MF {

// 你需要做的：给 n,s,t 赋值，用 addEdge 加边，然后调用 dinic 函数获得这个网络的最大流

const int kMaxN = 100005;
const int kMaxM = 1000005;
const long long kInf = 1e15;

int n, s, t;

struct Edge {
	int u, v, nxt;
	long long w;
} e[kMaxM];
int head[kMaxN], tot = 1;


void addEdge(int u, int v, long long w) {
	e[++tot].u = u, e[tot].v = v, e[tot].w = w;
	e[tot].nxt = head[u], head[u] = tot;
	
	e[++tot].u = v, e[tot].v = u, e[tot].w = 0;
	e[tot].nxt = head[v], head[v] = tot;
}

long long dis[kMaxN];
bool vis[kMaxN];

bool bfs() {
	queue<int> que;
	fill(dis + 1, dis + n + 1, kInf), fill(vis + 1, vis + n + 1, 0);
	que.emplace(s); dis[s] = 0, vis[s] = 1;
	while (!que.empty()) {
		int x = que.front(); que.pop();
		for (int i = head[x]; i; i = e[i].nxt) {
			if (vis[e[i].v] || !e[i].w) continue;
			vis[e[i].v] = 1;
			dis[e[i].v] = dis[x] + 1;
			que.emplace(e[i].v);
		}
	}
	return dis[t] < kInf;
}

int cur[kMaxN];

long long dfs(int now, long long flow) {
	if (now == t) return flow;
	long long rest = flow;
	for (int &i = cur[now]; i; i = e[i].nxt) {
		if (!e[i].w || dis[now] + 1 != dis[e[i].v]) continue;
		long long t = dfs(e[i].v, min(e[i].w, rest));
		e[i].w -= t, e[i ^ 1].w += t;
		rest -= t;
		if (!rest) break;
	}
	return flow - rest;
}

long long dinic() {
	long long ans = 0;
	while (bfs()) {
		for (int i = 1; i <= n; ++i) cur[i] = head[i];
		ans += dfs(s, kInf);
	}
	return ans;
}

}

const int kMaxN = 55;

int H, W;

string ch[kMaxN];

int in_node[kMaxN][kMaxN], out_node[kMaxN][kMaxN]; 
int tot;

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
	
	cin >> H >> W;
	MF::s = ++MF::n, MF::t = ++MF::n;
	for (int i = 1; i <= H; ++i) {
		cin >> ch[i];
		ch[i] = " " + ch[i];
		for (int j = 1; j <= W; ++j) {
			in_node[i][j] = ++MF::n, out_node[i][j] = ++MF::n;
			if (ch[i][j] == '#') {
				MF::addEdge(in_node[i][j], out_node[i][j], 1);
			}
		}
	}
	for (int i = 1; i <= H; ++i) {
		MF::addEdge(MF::s, in_node[i][1], MF::kInf);
		MF::addEdge(out_node[i][W], MF::t, MF::kInf);
	}
	for (int i = 1; i <= W; ++i) {
		MF::addEdge(MF::s, in_node[H][i], MF::kInf);
		MF::addEdge(out_node[1][i], MF::t, MF::kInf);
	}
	for (int i = 1; i <= H; ++i) {
		for (int j = 1; j <= W; ++j) {
			for (int k = 1; k <= H; ++k) {
				for (int l = 1; l <= W; ++l) {
					if (max({i - k, k - i, j - l, l - j}) <= 2) {
						MF::addEdge(out_node[i][j], in_node[k][l], MF::kInf);
					}
				}
			}
		}
	}
	cout << MF::dinic() << '\n';
	return 0;
}