#include <bits/stdc++.h>




namespace zawa {

using i16 = std::int16_t;
using i32 = std::int32_t;
using i64 = std::int64_t;
using i128 = __int128_t;

using u8 = std::uint8_t;
using u16 = std::uint16_t;
using u32 = std::uint32_t;
using u64 = std::uint64_t;

using usize = std::size_t;

} // namespace zawa


namespace zawa {

void SetFastIO() {
    std::cin.tie(nullptr)->sync_with_stdio(false);
}

void SetPrecision(u32 dig) {
    std::cout << std::fixed << std::setprecision(dig);
}

} // namespace zawa
using namespace zawa;

int main() {
    SetFastIO();

    int n, m; std::cin >> n >> m;
    std::vector<int> x(m);
    for (auto& v : x) std::cin >> v;

    std::map<std::vector<int>, std::vector<int>> map;
    bool ans{};
    for (int i{} ; i < n ; i++) {
        std::vector<int> c(m);
        for (auto& v : c) std::cin >> v;
        long long t; std::cin >> t;
        std::vector<int> left(m), right(m);
        if (t < 100) {
            bool can{true};
            for (int k{} ; k < m ; k++) {
                can &= ((10000 * x[k] - 100 * t * c[k]) % (100 - t)) == 0;
                left[k] = (10000 * x[k] - 100 * t * c[k]) / (100 - t);
            }
            if (can) map[left].push_back(i + 1);
        }
        else {
            ans |= x == c;
        }
        for (int k{} ; k < m ; k++) {
            right[k] = t * c[k];
        }
        map[right].push_back(-i - 1);
    }

    for (const auto& [_, index] : map) {
        std::vector<int> pos, neg;
        for (auto x : index) {
            if (x > 0) pos.push_back(x);
            else if (x < 0) neg.push_back(x);
            else assert(false);
        }
        if (neg.empty()) continue;
        for (auto v : pos) {
            ans |= neg[0] * -1 != v;
            ans |= (neg.size() > 1u and neg[1] * -1 != v);
        }
    }
    std::cout << (ans ? "Yes" : "No") << '\n';
}