#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 8000
#define SIZE 105

enum Type{
	Right_Under,
	Left_Under,
	Right_Up,
	Left_Up,
};

struct Edge{
	Edge(int arg_x1,int arg_y1, int arg_x2,int arg_y2){
		x1 = arg_x1;
		y1 = arg_y1;
		x2 = arg_x2;
		y2 = arg_y2;
	}
	int x1,y1,x2,y2;
};

int H,W;
int V;
vector<int> G[NUM];
int match[NUM];
bool used[NUM];
bool check[SIZE][SIZE][4];
char base_map[SIZE][SIZE];
vector<Edge> TATE,YOKO;


void add_edge(int from,int to){
	G[from].push_back(to);
	G[to].push_back(from);
}

int dfs(int node_id){
	used[node_id] = true;

	for(int i = 0; i < G[node_id].size(); i++){
		int adj_node_id = G[node_id][i],pair_id = match[adj_node_id];
		if((pair_id < 0)||
				(used[pair_id] == false && dfs(pair_id) == true)){
			match[node_id] = adj_node_id;
			match[adj_node_id] = node_id;
			return true;
		}
	}
	return false;
}


int bipartie_matching(){
	int ret = 0;
	for(int i = 0; i < V; i++)match[i] = -1;
	for(int node_id = 0; node_id < V; node_id++){
		if(match[node_id] < 0){
			for(int i = 0; i < V; i++)used[i] = false;
			if(dfs(node_id)){
				ret++;
			}
		}
	}
	return ret;
}

bool rangeCheck(int row,int col){
	if(row >= 0 && row <= H-1 && col >= 0 && col <= W-1){
		return true;
	}else{
		return false;
	}
}

void func(){

	TATE.clear();
	YOKO.clear();

	for(int x = 0; x <= W; x++){
		for(int y = 0; y <= H; y++){
			for(int a = 0; a < 4; a++){
				check[x][y][a] = false;
			}
		}
	}

	for(int row = 0; row < H; row++){
		scanf("%s",base_map[row]);
	}

	int num_cut_point = 0;
	int tmp_x,tmp_y;

	for(int row = 0; row < H; row++){
		for(int col = 0; col < W; col++){
			if(base_map[row][col] == '#')continue;

			//Right_Under
			if(rangeCheck(row+1,col+1) == true && base_map[row][col+1] == '#' &&
					base_map[row+1][col] == '#' && base_map[row+1][col+1] == '#'){

				tmp_x = col+1;
				tmp_y = row+1;

				check[tmp_x][tmp_y][Right_Under] = true;

				num_cut_point++;
			}

			//Left_Under
			if(rangeCheck(row+1,col-1) == true && base_map[row][col-1] == '#' &&
					base_map[row+1][col] == '#' && base_map[row+1][col-1] == '#'){

				tmp_x = col;
				tmp_y = row+1;

				check[tmp_x][tmp_y][Left_Under] = true;

				num_cut_point++;
			}

			//Right_Up
			if(rangeCheck(row-1,col+1) == true && base_map[row-1][col] == '#' &&
					base_map[row-1][col+1] == '#' && base_map[row][col+1] == '#'){

				tmp_x = col+1;
				tmp_y = row;

				check[tmp_x][tmp_y][Right_Up] = true;

				num_cut_point++;
			}

			//Left_Up
			if(rangeCheck(row-1,col-1) == true && base_map[row-1][col] == '#' &&
					base_map[row-1][col-1] == '#' && base_map[row][col-1] == '#'){

				tmp_x = col;
				tmp_y = row;

				check[tmp_x][tmp_y][Left_Up] = true;

				num_cut_point++;
			}
		}
	}

	for(int y = 0; y <= H; y++){
		for(int x = 0; x < W; x++){

			if(check[x][y][Right_Under] == true || check[x][y][Right_Up] == true){

				for(int another = x+1; another <= W; another++){

					if(rangeCheck(y-1,another-1) == false || rangeCheck(y,another) == false ||
							base_map[y-1][another-1] == '.' || base_map[y][another-1] == '.'){
						break;
					}

					if(check[another][y][Left_Under] == true || check[another][y][Left_Up] == true){
						YOKO.push_back(Edge(x,y,another,y));
						break;
					}
				}
			}
		}
	}

	for(int x = 0; x <= W; x++){
		for(int y = 0; y < H; y++){
			if(check[x][y][Right_Under] == true || check[x][y][Left_Under] == true){

				for(int another = y+1; another <= H; another++){

					if(rangeCheck(another-1,x-1) == false || rangeCheck(another-1,x) == false ||
							base_map[another-1][x-1] == '.' || base_map[another-1][x] == '.'){
						break;
					}

					if(check[x][another][Right_Up] == true || check[x][another][Left_Up] == true){
						TATE.push_back(Edge(x,y,x,another));
						break;
					}
				}
			}
		}
	}

	V = (int)TATE.size()+(int)YOKO.size();

	for(int i = 0; i < NUM; i++){
		G[i].clear();
	}

	for(int i = 0; i < YOKO.size(); i++){
		for(int k = 0; k < TATE.size(); k++){
			if(TATE[k].x1 >= YOKO[i].x1 && TATE[k].x1 <= YOKO[i].x2 && YOKO[i].y1 >= TATE[k].y1 && YOKO[i].y1 <= TATE[k].y2){
				add_edge(i,(int)YOKO.size()+k);
			}
		}
	}

	printf("%d\n",num_cut_point-(V-bipartie_matching())+1);
}

int main(){

	while(true){

		scanf("%d %d",&H,&W);
		if(H == 0 && W == 0)break;

		func();
	}

	return 0;
}



Measured memory_bytes: 3868