use std::io::BufRead;
fn main() {
    let f = read_field();
    println!("{}", if solve(&f) { "Yes" } else { "No" })
}

fn solve(f: &Field) -> bool {
    for y in 0..f.h {
        for x in 0..f.w {
            if f.at(x, y).unwrap_or(false) {
                // we need to paint here
                if !&[
                    (x.checked_sub(1), Some(y)),
                    (Some(x + 1), Some(y)),
                    (Some(x), y.checked_sub(1)),
                    (Some(x), Some(y + 1)),
                ]
                .iter()
                .any(|&(nx, ny)| f.at_opt(nx, ny).unwrap_or(false))
                {
                    return false;
                }
            }
        }
    }
    true
}

fn read_field() -> Field {
    let stdin = std::io::stdin();
    let mut input = stdin.lock();
    let mut l = String::new();
    let _ = input.read_line(&mut l);
    let hw: Vec<u32> = l
        .split_whitespace()
        .map(|n| n.parse().expect("readnumerror!"))
        .collect();
    let h = hw[0];
    let w = hw[1];
    let mut f: Vec<Cell> = Vec::with_capacity((h * w) as usize);
    for line in input.lines() {
        for c in line.expect("read line error").trim().chars() {
            match c {
                '.' => f.push(false),
                '#' => f.push(true),
                _ => panic!(format!("unexpected char {}", c)),
            }
        }
    }
    Field {
        h: h,
        w: w,
        field: f,
    }
}

struct Field {
    h: u32,
    w: u32,
    field: Vec<Cell>,
}

impl Field {
    fn at_opt(&self, x: Option<u32>, y: Option<u32>) -> Option<Cell> {
        if x? < self.w && y? < self.h {
            self.field
                .get(x? as usize + y? as usize * (self.w as usize))
                .copied()
        } else {
            None
        }
    }
    fn at(&self, x: u32, y: u32) -> Option<Cell> {
        if x < self.w && y < self.h {
            self.field
                .get(x as usize + y as usize * (self.w as usize))
                .copied()
        } else {
            None
        }
    }
}

type Cell = bool;
