# define _SCL_SECURE_NO_WARNINGS

# include <iostream>
# include <string>
# include <iomanip>
# include <stdio.h>
# include <array>
# include <numeric>
# include <algorithm>
# include <vector>
# include <functional>



using Ull = unsigned long long;
using Ll = long long;

//namespace TechFUL_i4
//{

namespace mine
{

    template<typename T>
    std::istream& operator >> (std::istream& is, std::vector<T>& vec)
    {
        for (T& x : vec) is >> x;
        return is;
    }

    template<typename T>
    std::string to_string(std::vector<T> vec, std::string sep = " ")
    {
        std::string result;
        for (T& x : vec) result += std::to_string(x) + sep;
        result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L>
    std::string to_string(T(&ary)[L], std::string sep = " ", size_t size = L)
    {
        std::string result;
        for (int i = 0; i < size; ++i) result += std::to_string(ary[i]);
        result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L, typename Function>
    void for_each(T(&ary)[L], Function lambda)
    {
        for (size_t i{}; i < L; ++i)
            lambda(static_cast<T&>(ary[i]));
    }

    template<typename T>
    void SetAll(T container, typename T::value_type value = typename T::value_type{})
    {
        for (typename T::reference content : container)
            content = value;
    }

    template<typename T, size_t L>
    void SetAll(T(&ary)[L], T value = T{})
    {
        for (size_t i{}; i < L; ++i)
            ary[i] = value;
    }

    template<typename T, size_t L>
    std::array<T, L> AsContainer(T(&ary)[L], bool isSwap = true)
    {
        std::array<T, L> result;

        if (isSwap)
        {
            for (size_t i{}; i < L; ++i)
                std::swap(result[i], ary[i]);
        }
        else
        {
            for (size_t i{}; i < L; ++i)
                result[i] = ary[i];
        }

        return result;
    }

    template<size_t length>
    constexpr std::array<size_t, length> range()
    {
        std::array<size_t, length> range{};

        for (size_t i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T length)
    {
        std::vector<T> range(length);

        for (T i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    /// <summary>
    /// 最初と最後を含める
    /// </summary>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <returns></returns>
    template<typename T>
    const std::vector<T> range(const T start, const T end)
    {
        std::vector<T> range(end - start + 1);

        for (T i{start}; i <= end; ++i)
            range[i] = i;

        return range;
    }

}
using namespace mine;


//namespace C
//{
int main()
{
    int H, W;
    std::cin >> H >> W;
    std::vector<std::vector<char>> data(H, std::vector<char>(W));
    std::cin >> data;
    
    
    for(auto h : range(H))
    for(auto w : range(W))
    {
        if (data[h][w] == '#' || data[h][w] == ',')
        {
            if (h - 1 >= 0 && data[h - 1][w] == '#') data[h - 1][w] = ',';
            if (h + 1 <  H && data[h + 1][w] == '#') data[h + 1][w] = ',';
            if (w - 1 >= 0 && data[h][w - 1] == '#') data[h][w - 1] = ',';
            if (w + 1 <  W && data[h][w + 1] == '#') data[h][w + 1] = ',';
        }
    }

    auto result{true};
    for (auto h : range(H))
    for (auto w : range(W))
    {
        if (data[h][w] == '#') 
        {
            result = false;
            goto END;
        }
    }
    END:


    std::cout << (result ? "Yes" : "No");
    

    return 0;
}
//}

Measured memory_bytes: 256