#include <iostream>
#include <sstream>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <array>
#include <list>
#include <map>
#include <bitset>
#include <memory>
#include <algorithm>
#include <utility>
#include <numeric>

namespace Util
{

std::vector<std::string> Split(const std::string& str, const char delim);
std::string Itos(const int value);
std::string Ftos(const double value);
int Stoi(const std::string& buf);
double Stof(const std::string& buf);
std::vector<int> ConvertInt(const std::vector<std::string>& buffers);
std::vector<double> ConvertDouble(const std::vector<std::string>& buffers);

}// namespace Util


namespace Color
{
	const char Black = '#';
	const char White = '.';
	const char Blue = 'o';
	const char Red = 'x';
};

const std::vector< std::vector<int> > color =
{
	{1, 1, 1, 0, 0, 0, 0, 0},
	{1, 0, 1, 2, 2, 2, 0, 0},
	{0, 0, 1, 2, 1, 2, 0, 0},
	{0, 0, 1, 1, 1, 2, 0, 2},
	{0, 0, 0, 0, 0, 2, 2, 2},
};

struct Point
{
	int y;
	int x;
};

bool Check(std::vector< std::vector<char> >& field, const std::vector<Point>& blackPoint, const Point& dis)
{
	int count = 0;

	for(int cur = 0; cur < static_cast<int>(blackPoint.size()); ++cur)
	{
		if(field[ blackPoint[cur].y ][ blackPoint[cur].x ] == Color::Black)
		{
			field[ blackPoint[cur].y ][ blackPoint[cur].x ] = Color::Red;

			if( ( 0 <= blackPoint[cur].y + dis.y && blackPoint[cur].y + dis.y < static_cast<int>(field.size()) ) &&
				( 0 <= blackPoint[cur].x + dis.x && blackPoint[cur].x + dis.x < static_cast<int>(field.front().size()) ) )
			{
				if(field[ blackPoint[cur].y + dis.y ][ blackPoint[cur].x + dis.x ] == Color::Black)
				{
					field[ blackPoint[cur].y + dis.y ][ blackPoint[cur].x + dis.x ] = Color::Blue;
					++count;
				}
				else
				{
					break;
				}
			}
			else
			{
				break;
			}
		}
	}

	return 0 < count && count * 2 == static_cast<int>(blackPoint.size());
}

void Show(const std::vector< std::vector<char> >& field, const char* format)
{
	for(auto& line : field)
	{
		for(auto& value : line)
		{
			printf(format, value);
		}
		printf("\n");
	}
}

int main()
{
	// 入出力の速度向上
	std::cin.tie(0);
	std::ios::sync_with_stdio(false);

	std::string buf;
	std::vector<std::string> buffers;

	std::vector< std::vector<char> > field;
	std::vector<Point> blackPoint;

	std::getline(std::cin, buf);
	buffers = Util::Split(buf, ' ');

	field.resize(Util::Stoi(buffers[0]));
	for(int line = 0; line < static_cast<int>(field.size()); ++line)
	{
		field[line].resize(Util::Stoi(buffers[1]));

		std::getline(std::cin, buf);
		for(int cur = 0; cur < static_cast<int>(field[line].size()); ++cur)
		{
			field[line][cur] = buf[cur];

			if(field[line][cur] == Color::Black)
			{
				blackPoint.emplace_back(Point({line, cur}));
			}
		}
	}

	std::vector< std::vector<char> > backup(field);
	bool able = false;

	for(int line = 0; line < 1; ++line)
	{
		for(int cur = 0; cur < static_cast<int>(field[line].size()); ++cur)
		{
			field = backup;
			if(Check(field, blackPoint, {line, cur}) == true)
			{
				able = true;
				break;
			}
		}
	}

	for(int line = 1; line < static_cast<int>(field.size()); ++line)
	{
		for(int cur = -static_cast<int>(field[line].size()); cur < static_cast<int>(field[line].size()); ++cur)
		{
			field = backup;
			if(Check(field, blackPoint, {line, cur}) == true)
			{
				able = true;
				break;
			}
		}
	}

	printf("%s\n", able == true ? "YES" : "NO");


	return 0;
}


namespace Util
{

std::vector<std::string> Split(const std::string& str, const char delim)
{
	std::istringstream iss(str);
	std::vector<std::string> ret;
	std::string tmp;

	while(std::getline(iss, tmp, delim))
	{
		ret.push_back(tmp);
	}

	return ret;
}

std::string Itos(const int value)
{
	std::ostringstream ostream;
	ostream << value;
	return ostream.str();
}

std::string Itof(const double value)
{
	std::ostringstream ostream;
	ostream << value;
	return ostream.str();
}

int Stoi(const std::string& buf)
{
	return std::atoi(buf.c_str());
}

double Stof(const std::string& buf)
{
	return std::atof(buf.c_str());
}

std::vector<int> ConvertInt(const std::vector<std::string>& buffers)
{
	std::vector<int> ret(buffers.size());

	for(int cur = 0; cur < static_cast<int>(ret.size()); ++cur)
	{
		ret[cur] = Stoi(buffers[cur]);
	}

	return ret;
}

std::vector<double> ConvertDouble(const std::vector<std::string>& buffers)
{
	std::vector<double> ret(buffers.size());

	for(int cur = 0; cur < static_cast<int>(ret.size()); ++cur)
	{
		ret[cur] = Stof(buffers[cur]);
	}

	return ret;
}

}// namespace Util