(use srfi-1)
(use gauche.array)

(define DEBUG #f)

(define (read-n n)
  (letrec ((read-n-impl (lambda (n rv)
    (if (= n 0)
      rv
      (read-n-impl (- n 1) (cons (read) rv))))))
   (reverse (read-n-impl n '())) ))

(define (read-n-m n m)
  (let loop ((i 0)
             (rv (list)))
    (if (= i n)
      (reverse rv)
      (loop (+ i 1) (cons 
                      (let loop2 ((j 0)
                                  (rvi (list)))
                        (if (= j m)
                          (reverse rvi)
                          (loop2 (+ j 1) (cons (read) rvi))))
                      rv)))))

(define (read-lines n)
  (letrec ((read-lines-impl (lambda (n rv)
    (if (= n 0)
      rv
      (read-lines-impl (- n 1)
                       (cons (read-line) rv))))))
   (reverse (read-lines-impl n '())) ))

(define (output n)
  (if (list? n)
    (let loop ((n n))
     (if (null? n)
       #f
       (begin
         (display (car n))
         (let ((nn (cdr n)))
          (if (null? nn)
            (newline)
            (begin
              (display " ")
              (loop nn)))))))
    (when (or (not (string? n))
              (not (string=? n "")))
      (display n) 
      (newline))))

; --------

(define-class <largenum> () (
  (n
    :accessor largenum-n
    :init-keyword :n
    :init-form (error "need n"))))

(define *largenum-base* (+ (expt 10 9) 7))

(define (largenum-normalize n)
  (modulo (+ n *largenum-base*) *largenum-base*))

(define (largenum n)
  (make <largenum> :n (largenum-normalize n)))

(define-method = ((x <largenum>) (y <largenum>))
  (= (largenum-n x) (largenum-n y)))
(define-method + ((x <largenum>) (y <largenum>))
  (largenum (largenum-normalize (+ (largenum-n x) (largenum-n y)))))
(define-method - ((x <largenum>) (y <largenum>))
  (largenum (largenum-normalize (- (largenum-n x) (largenum-n y)))))
(define-method * ((x <largenum>) (y <largenum>))
  (largenum (largenum-normalize (* (largenum-n x) (largenum-n y)))))

(define-method display ((x <largenum>))
  (display (largenum-n x)))

; --------

(define (roundup-quotient n1 n2)
  (+ (quotient n1 n2) (if (= (modulo n1 n2) 0) 0 1)))

(define (factorization n)
  (let ((end (sqrt n)))
   (let loop ((t n)
              (ret (list))
              (i 2))
     (if (or (<= end i) (= t 1))
       (if (not (= t 1))
         (cons (cons t 1) ret)
         (if (null? ret)
           (list (cons n 1))
           ret))
       (if (= (modulo t i) 0)
         (let loop2 ((cnt 0)
                     (t t))
           (if (= (modulo t i) 0)
             (loop2 (+ cnt 1) (quotient t i))
             (loop t (cons (cons i cnt) ret) (+ i 1))))
         (loop t ret (+ 1 i)))))))

(define (uniq lst)
  (reverse (first (fold (lambda (i a)
                          (let ((rv (first a))
                                (last (second a)))
                            (if (equal? i last)
                              a
                              (list (cons i rv) i))))
                        (list (list (first lst)) (first lst))
                        lst))))

(define (minf a b)
  (if a
    (min a b)
    b))

(define (1st x) (car x))
(define (2nd x) (cadr x))
(define (3rd x) (caddr x))
(define (4th x) (cadddr x))

; --------

(set! (setter array-ref) array-set!)

(define (map-with-index f lst)
  (let loop ((lst lst)
             (rv (list))
             (i 0))
    (if (null? lst)
      (reverse rv)
      (loop (cdr lst) (cons (f (car lst) i) rv) (+ i 1)))))

; --------

(define-method describe ((a <array>))
  (display "#,(<array> ")
  (array-for-each-index a (^ (y x)
    (when (= x 0)
      (newline))
    (display (array-ref a y x))
    (display " ")))
  (display "is an instance of class <array>")
  (newline))

(define-method describe ((a <list>))
  (display a)
  (newline))

(define-method describe ((a <vector>))
  (display a)
  (newline))

(define-method describe ((a <number>))
  (display a)
  (newline))

(define-method describe ((a <boolean>))
  (display a)
  (newline))

(define-method describe ((a <string>))
  (display a)
  (newline))

(define-method describe ((a <char>))
  (display a)
  (newline))

(define-method describe ((a <hash-table>))
  (display (hash-table->alist a))
  (newline))

;(define (describe . o))

(define-syntax debug
  (syntax-rules ()
    ((_ x) (when DEBUG
             (display (quote x))
             (display ":")
             (describe x)))))

;(define-syntax debug (syntax-rules () ((_ x) #f))) 

(define-syntax dd
  (syntax-rules ()
    ((_ x y) (begin (define x y) (debug x)))))

(define-syntax dlet-debug
  (syntax-rules ()
    ((_ (x y))
     (debug x))
    ((_ (x y) . z)
     (begin
       (dlet-debug (x y))
       (dlet-debug . z)))))

(define-syntax dlet
  (syntax-rules ()
                ((_ (x) . y)
                 (let (x)
                  (dlet-debug x)
                  . y))  
                ((_ (x . xs) . y)
                 (let (x . xs)
                  (dlet-debug x)
                  (dlet-debug . xs)
                  . y))  
                ((_ label (x) . y)
                 (let label (x)
                  (debug "-----")
                  (dlet-debug x)
                  . y))  
                ((_ label (x . xs) . y)
                 (let label (x . xs)
                  (debug "-----")
                  (dlet-debug x)
                  (dlet-debug . xs)
                  . y))))

(define-syntax dlet*
  (syntax-rules ()
                ((_ (x) . y)
                 (let* (x)
                  (dlet-debug x)
                  . y))  
                ((_ (x . xs) . y)
                 (let* (x . xs)
                  (dlet-debug x)
                  (dlet-debug . xs)
                  . y))  
                ((_ label (x . xs) . y)
                 (let* label (x . xs)
                  (debug "-----")
                  (dlet-debug x)
                  (dlet-debug . xs)
                  . y))))

(define-syntax dif
  (syntax-rules ()
                ((_ c t f)
                 (begin
                   (debug c)
                   (if c t f)))))

; --------

(dd H (read))
(dd W (read))
(read-line)
(dd S (list->vector
        (map list->vector
             (map (^(l) (map (^(c) (if (equal? #\# c) #t #f)) l))
                  (map string->list (read-lines H))))))

(for-each
  (^ (y)
     (for-each
       (^ (x)
          (when (ref (ref S x) y)
            (unless (or
                      (and
                        (< 0 y)
                        (or
                          (ref (ref S x) (- y 1))
                          ))
                      (or
                        (and (< 0 x)
                             (ref (ref S (- x 1)) y))
                        (and (< x W)
                             (ref (ref S (+ x 1)) y))) 
                      (and
                        (< y H)
                        (or
                          (ref (ref S x) (+ y 1))
                          )))
              (output "No")
              (exit))))
       (iota W)))
  (iota H))
(output "Yes")
