output_description: If square1001 can achieve his objective, print `Yes`; if he cannot, print
  `No`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      H W
      s_{1, 1} s_{1, 2} s_{1, 3} ... s_{1, W}
      s_{2, 1} s_{2, 2} s_{2, 3} ... s_{2, W}
        :   :
      s_{H, 1} s_{H, 2} s_{H, 3} ... s_{H, W}
attempt: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  
  input = sys.stdin.readline
  
  import math
  
  # from math import gcd
  import bisect
  from collections import defaultdict
  from collections import deque
  from functools import lru_cache
  
  
  #############
  # Constants #
  #############
  
  MOD = 10**9 + 7
  INF = float("inf")
  
  #############
  # Functions #
  #############
  
  
  ######INPUT######
  def I():
      return int(input().strip())
  
  
  def S():
      return input().strip()
  
  
  def IL():
      return list(map(int, input().split()))
  
  
  def SL():
      return list(map(str, input().split()))
  
  
  def ILs(n):
      return list(int(input()) for _ in range(n))
  
  
  def SLs(n):
      return list(input().strip() for _ in range(n))
  
  
  def ILL(n):
      return [list(map(int, input().split())) for _ in range(n)]
  
  
  def SLL(n):
      return [list(map(str, input().split())) for _ in range(n)]
  
  
  ######OUTPUT######
  def P(arg):
      print(arg)
      return
  
  
  def Y():
      print("Yes")
      return
  
  
  def N():
      print("No")
      return
  
  
  def E():
      exit()
  
  
  def PE(arg):
      print(arg)
      exit()
  
  
  def YE():
      print("Yes")
      exit()
  
  
  def NE():
      print("No")
      exit()
  
  
  #####Shorten#####
  def DD(arg):
      return defaultdict(arg)
  
  
  #####Inverse#####
  def inv(n):
      return pow(n, MOD - 2, MOD)
  
  
  ######Combination######
  kaijo_memo = []
  
  
  def kaijo(n):
      if len(kaijo_memo) > n:
          return kaijo_memo[n]
      if len(kaijo_memo) == 0:
          kaijo_memo.append(1)
      while len(kaijo_memo) <= n:
          kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
      return kaijo_memo[n]
  
  
  gyaku_kaijo_memo = []
  
  
  def gyaku_kaijo(n):
      if len(gyaku_kaijo_memo) > n:
          return gyaku_kaijo_memo[n]
      if len(gyaku_kaijo_memo) == 0:
          gyaku_kaijo_memo.append(1)
      while len(gyaku_kaijo_memo) <= n:
          gyaku_kaijo_memo.append(
              gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD
          )
      return gyaku_kaijo_memo[n]
  
  
  def nCr(n, r):
      if n == r:
          return 1
      if n < r or r < 0:
          return 0
      ret = 1
      ret = ret * kaijo(n) % MOD
      ret = ret * gyaku_kaijo(r) % MOD
      ret = ret * gyaku_kaijo(n - r) % MOD
      return ret
  
  
  ######Factorization######
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
      if temp != 1:
          arr.append([temp, 1])
      if arr == []:
          arr.append([n, 1])
      return arr
  
  
  #####MakeDivisors######
  def make_divisors(n):
      divisors = []
      for i in range(1, int(n**0.5) + 1):
          if n % i == 0:
              divisors.append(i)
              if i != n // i:
                  divisors.append(n // i)
      return divisors
  
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd(a, b)
  
  
  #####BitCount#####
  def count_bit(n):
      count = 0
      while n:
          n &= n - 1
          count += 1
      return count
  
  
  #####ChangeBase#####
  def base_10_to_n(X, n):
      if X // n:
          return base_10_to_n(X // n, n) + [X % n]
      return [X % n]
  
  
  def base_n_to_10(X, n):
      return sum(int(str(X)[-i]) * n**i for i in range(len(str(X))))
  
  
  #####IntLog#####
  def int_log(n, a):
      count = 0
      while n >= a:
          n //= a
          count += 1
      return count
  
  
  #############
  # Main Code #
  #############
  
  H, W = IL()
  S = SLs(H)
  dx = [
      -1,
      0,
      1,
      0,
  ]
  dy = [
      0,
      -1,
      0,
      1,
  ]
  
  for x in range(H):
      for y in range(W):
          if S[x][y] == "#":
              flag = 0
              for i in range(4):
                  nx = dx[i] + x
                  ny = dy[i] + y
                  if 0 <= nx < H and 0 <= ny < W:
                      if S[nx][ny] == "#":
                          flag = 1
              if flag == 0:
                  NE()
  Y()
  
problem_description: Statement
  
  We have a canvas divided into a grid with H rows and W columns. The square at
  the i-th row from the top and the j-th column from the left is represented as
  (i, j).  
  Initially, all the squares are white. square1001 wants to draw a picture with
  black paint. His specific objective is to make Square (i, j) black when s_{i,
  j}= `#`, and to make Square (i, j) white when s_{i, j}= `.`.  
  However, since he is not a good painter, he can only choose two squares that
  are horizontally or vertically adjacent and paint those squares black, for
  some number of times (possibly zero). He may choose squares that are already
  painted black, in which case the color of those squares remain black.  
  Determine if square1001 can achieve his objective.
samples: [{"input": "3 3\n    .#.\n    ###\n    .#.", "output": "Yes\n    \n\nOne possible way to achieve the objective is shown in the figure below. Here,\nthe squares being painted are marked by stars.\n\n![ ](https://img.atcoder.jp/abc096/18f94b6627ec5dc8aa4f6d99ae1c8fca.png)\n\n* * *"}, {"input": "5 5\n    #.#.#\n    .#.#.\n    #.#.#\n    .#.#.\n    #.#.#", "output": "No\n    \n\nsquare1001 cannot achieve his objective here.\n\n* * *"}, {"input": "11 11\n    ...#####...\n    .##.....##.\n    #..##.##..#\n    #..##.##..#\n    #.........#\n    #...###...#\n    .#########.\n    .#.#.#.#.#.\n    ##.#.#.#.##\n    ..##.#.##..\n    .##..#..##.", "output": "Yes"}]