import Control.Monad
import Control.Applicative
import qualified Data.Map as Map

main = do
    [h,w] <- map read . words <$> getLine :: IO [Int]
    d <- forM [1..h] $ \raw -> do
       line <- map f <$> getLine 
       return (g raw line)
    putStrLn $ solve (Map.fromList (concat d)) h w

solve :: Arr -> Int -> Int -> String
solve dict h w = if solvable dict h w
                    then "Yes"
                    else "No"

solvable :: Arr -> Int -> Int -> Bool
solvable dict h w = and $ map (okay dict h w) keys
    where keys = Map.keys dict 


type Arr = Map.Map (Int,Int) Bool

adj :: Int -> Int -> (Int,Int) -> [(Int,Int)]
adj h w (i,j) = filter fil [(i-1,j),(i+1,j),(i,j-1),(i,j+1)]
    where fil (x,y) = and [1<=x,x<=h,1<=y,y<=w]

okay :: Arr -> Int -> Int -> (Int,Int) -> Bool
okay dict h w (i,j) = if ok dict (i,j)
                         then or (map (ok dict) (adj h w (i,j)))
                         else True

ok dict (i,j) = dict Map.! (i,j)

dic :: Int -> Int -> Map.Map (Int,Int) Bool
dic h w= Map.fromList (zip keys falses)
    where falses = repeat False
          keys = [(i,j)| i <- [1..h], j <- [1..w]]

f :: Char -> Bool
f '#' = True
f '.' = False

g :: Int -> [Bool] -> [((Int,Int),Bool)]
g raw line = map h line'
    where h = \(col,b) -> ((raw,col),b)
          line' = zip [1..] line
