// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx2,bmi,bmi2,lzcnt")
// #define NDEBUG

#include <bits/extc++.h>
#include <x86intrin.h>

struct rep {
  struct iter {
    int i;
    constexpr void operator++() { ++i; }
    constexpr int operator*() const { return i; }
    friend constexpr bool operator!=(iter a, iter b) { return *a != *b; }
  };
  const int l, r;
  constexpr rep(int _l, int _r) : l(std::min(_l, _r)), r(_r) {}
  constexpr rep(int n) : rep(0, n) {}
  constexpr iter begin() const { return {l}; }
  constexpr iter end() const { return {r}; }
};
struct per {
  struct iter {
    int i;
    constexpr void operator++() { --i; }
    constexpr int operator*() const { return i; }
    friend constexpr bool operator!=(iter a, iter b) { return *a != *b; }
  };
  const int l, r;
  constexpr per(int _l, int _r) : l(std::min(_l, _r)), r(_r) {}
  constexpr per(int n) : per(0, n) {}
  constexpr iter begin() const { return {r - 1}; }
  constexpr iter end() const { return {l - 1}; }
};
template <class T, class U>
constexpr bool chmin(T& a, U&& b) {
  return b < a ? a = std::forward<U>(b), true : false;
}
template <class T, class U>
constexpr bool chmax(T& a, U&& b) {
  return a < b ? a = std::forward<U>(b), true : false;
}

template <class F>
struct y_combinator : private F {
  y_combinator(F f) : F(f) {}
  template <class... Args>
  decltype(auto) operator()(Args&&... args) const {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};

int main() {
  using namespace std;
  cin.tie(nullptr)->sync_with_stdio(false);
  int64_t n;
  int k;
  cin >> n >> k;
  vector<int64_t> a(k);
  for (auto&& e : a) cin >> e;

  map<int64_t, bool> mp;
  auto ok = y_combinator([&](auto&& self, auto s) -> bool {
    auto it = lower_bound(begin(a), end(a), s);
    if (it == end(a)) return true;
    if (mp.count(s)) return mp[s];
    if (*it - s < 20) {
      if (*it == s) return false;
      for (int x : rep(1, 4))
        if (not self(s + x) and not self(s + (7 - x))) return mp[s] = false;
      return mp[s] = true;
    } else {
      auto d = ((*it - s) / 6 - 1) * 6;
      return mp[s] = self(s + d);
    }
  })(1);

  cout << (ok ? "Yes\n" : "No\n");
}