import           Control.Monad
import           Control.Monad.ST
import qualified Data.Array                    as A
import qualified Data.Array.ST                 as ST
import qualified Data.Array.Unboxed            as AU
import qualified Data.ByteString.Char8         as BS
import           Data.Char
import           Data.Int
import qualified Data.IntMap                   as IM
import           Data.List
import qualified Data.Map                      as M
import           Data.Maybe
import           Data.Ord
import qualified Data.Set                      as S
import           Data.Time
import qualified Data.Vector                   as V
import qualified Data.Vector.Mutable           as VM
import qualified Data.Vector.Unboxed           as VU
import qualified Data.Vector.Unboxed.Mutable   as VUM

readInt :: IO [Int]
readInt = map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine

readInts :: Int -> IO [[Int]]
readInts n = replicateM n readInt

readString :: IO [String]
readString = map BS.unpack . BS.words <$> BS.getLine

readStrings :: Int -> IO [[String]]
readStrings n = replicateM n <$> readString

toPair :: [a] -> (a, a)
toPair [x, y] = (x, y)

main = do
    [h, w] <- readInt
    m      <- replicateM h getLine
    putStrLn $ solve m h w

solve :: [[Char]] -> Int -> Int -> String
solve m h w | b         = "Yes"
            | otherwise = "No"
  where
    am = A.array
        ((0, 0), (h - 1, w - 1))
        [ ((i, j), f $ m !! i !! j) | i <- [0 .. h - 1], j <- [0 .. w - 1] ]
    b = and [ g am u o h w | u <- [0 .. h - 1], o <- [0 .. w - 1] ]

g :: A.Array (Int, Int) Bool -> Int -> Int -> Int -> Int -> Bool
g am i j h w
    | am A.! (i, j) = am A.! (i, j) && any (\(i', j') -> am A.! (i', j'))
                                           (s i j h w)
    | otherwise = True

s i j h w =
    filter (\(a, b) -> 0 <= a && a < h && 0 <= b && b < w)
        $ [(i + 1, j), (i, j + 1), (i - 1, j), (i, j - 1)]

f :: Char -> Bool
f s | s == '#'  = True
    | otherwise = False
