program name
    use,intrinsic :: iso_fortran_env
    implicit none
    integer(int32):: h,w
    integer(int32):: i,j
    character(1),allocatable:: s(:,:)
    logical,allocatable:: bl(:,:), pnt(:,:), see(:,:)

    read*, h,w
    allocate(s(w,h),bl(w,h), pnt(w,h), see(w,h))
    bl(:,:) = .false.
    pnt(:,:) = .false.
    see(:,:) = .false.
    block
        character(w):: inpt_s
        do i = 1, h
            read*, inpt_s
            do j = 1, w
                s(j,i) = inpt_s(j:j)
                if (s(j,i) == '#') bl(j,i) = .true.
            end do
        end do
    end block
    
    block
        integer(int32):: nx,ny
        do
            call next(nx,ny)
            if (nx == 0 .and. ny == 0) exit
            call dfs(nx,ny)
        end do
    end block

    ! do i=1,h
    !     print*, bl(:,i)
    ! end do
    ! do i=1,h
    !     print*, pnt(:,i)
    ! end do
    
    do i = 1, h
        do j = 1, w
            if (.not.(bl(j,i) .eqv. pnt(j,i))) then
                print*, 'No'
                stop
            end if
        end do
    end do
    print*, 'Yes'
contains
    function naka(x,y) result(ret)
        integer(int32),intent(in):: x,y
        logical:: ret

        ret = 1<=x .and. x<=w .and. 1<=y .and. y<=h
    end function


    recursive subroutine dfs(x,y)
        integer(int32),intent(in):: x,y
        integer(int32):: dx,dy

        see(x,y) = .true.

        do dx = -1, 1
            do dy = -1, 1
                if (abs(dx) == abs(dy)) cycle
                if (.not. naka(x+dx,y+dy)) cycle
                if (bl(x+dx,y+dy) .and. .not. pnt(x+dx,y+dy)) then
                    pnt(x,y) = .true.
                    pnt(x+dx,y+dy) = .true.
                    if (.not. see(x+dx,y+dy)) call dfs(x+dx,y+dy)
                end if
            end do
        end do
        
    
    end subroutine
    subroutine next(x,y)
        integer(int32),intent(out):: x,y
        integer(int32):: i,j
        x=0
        y=0
        do i=1,h
            do j = 1, w
                if (bl(j,i) .and. (.not. see(j,i))) then
                    x=j
                    y=i
                    return
                end if
            end do
        end do
    end subroutine
end program name