use std::fmt;
use std::cmp;
use std::io::stdin;
use std::io::BufRead;
use std::str;
use std::str::FromStr;
use std::char;

fn main() {
	let stdin = stdin();
	let mut scan = InputScanner::new(stdin.lock(),256);

	let h:usize = scan.next();
	let w:usize = scan.next();

	let s = (0..h).map(|_| scan.next::<String>().chars().collect::<Vec<char>>()).collect::<Vec<Vec<char>>>();

	let mut count:i64 = s.iter().fold(0,|mut acc,l| {
		acc += l.iter().filter(|&&c| c == '#').count() as i64;
		acc
	});

	for y in 0..h {
		for x in 0..w {
			let mut c = 0;

			if s[y][x] != '#' {
				continue;
			}

			for cy in (cmp::max(0,y as i32 - 1) as usize)..cmp::min(y+2,h) {
				if s[cy][x] == '#' {
					c += 1;
				}
			}

			for cx in (cmp::max(0,x as i32 - 1) as usize)..cmp::min(x+2,w) {
				if s[y][cx] == '#' {
					c += 1;
				}
			}

			if h >= y+2 && w >= x+2 {
				c -= 1;
			}

			if c >= 2 {
				count -= c;
			}
		}
	}

	if count <= 0 {
		println!("Yes");
	} else {
		println!("No");
	}
}
struct InputScanner<R: BufRead> {
	reader: R,
	buf: Vec<u8>, // Should never be empty
	pos: usize,   // Should never be out of bounds as long as the input ends with '\n'
}
impl<R: BufRead> InputScanner<R> {
	fn new(reader: R, capacity: usize) -> Self {
		InputScanner {
			reader: reader,
			buf: Vec::with_capacity(capacity),
			pos: 0,
		}
	}

	#[inline]
	fn next<T: FromStr>(&mut self) -> T
	where
		T::Err: fmt::Debug,
	{
		if self.buf.is_empty() {
			self._read_next_line();
		}
		let mut start = None;
		loop {
			match (self.buf[self.pos], start.is_some()) {
				(b' ', true) | (b'\n', true) | (b'\r', true) => break,
				(_, true) | (b' ', false) => self.pos += 1,
				(b'\n', false) | (b'\r', false) => self._read_next_line(),
				(_, false) => start = Some(self.pos),
			}
		}
		let target = &self.buf[start.unwrap()..self.pos];
		unsafe { str::from_utf8_unchecked(target) }.parse().unwrap()
	}

	#[inline]
	fn _read_next_line(&mut self) {
		self.pos = 0;
		self.buf.clear();
		if self.reader.read_until(b'\n', &mut self.buf).unwrap() == 0 {
			panic!("Reached EOF");
		}
	}
}
