#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using uint8 = unsigned char;
using uint16 = unsigned short int;
using uint32 = unsigned int;
using uint64 = unsigned long long;
using int8 = signed char;
using int16 = short int;
using int32 = int;
using int64 = long long;
using pi32 = std::pair<int32, int32>;
using pi64 = std::pair<int64, int64>;
namespace oct {
const int tn4[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
const int tn8[8][2] = {{1, 0},  {1, 1},   {0, 1},  {-1, 1},
                       {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
const double exp = 1e-8;
void sync(int pre = 8);
template <typename _Tp>
_Tp &mad(_Tp &x, _Tp y);
template <typename _Tp>
_Tp &mid(_Tp &x, _Tp y);
template <typename _Tp>
bool in(_Tp x, _Tp l, _Tp r);
template <typename _Tp>
_Tp sqr(_Tp x);
template <typename _Tp>
_Tp power(_Tp x, int64 m);
template <typename _Tp>
void sort(_Tp &x, _Tp &y);
template <typename _Tp1, typename _Tp2>
std::pair<_Tp1, _Tp2> operator+(std::pair<_Tp1, _Tp2> x,
                                std::pair<_Tp1, _Tp2> y);
template <typename _Tp>
_Tp &operator+=(_Tp &x, _Tp y);
inline void sync(int pre) {
  std::ios::sync_with_stdio(0);
  std::cin.tie(0), std::cout.tie(0);
  std::cout.flags(std::ios::fixed);
  std::cout.precision(pre);
  std::cout.setf(std::ios::showpoint);
}
template <typename _Tp>
inline _Tp &mad(_Tp &x, _Tp y) {
  return x = std::max(x, y);
}
template <typename _Tp>
inline _Tp &mid(_Tp &x, _Tp y) {
  return x = std::min(x, y);
}
template <typename _Tp>
inline bool in(_Tp x, _Tp l, _Tp r) {
  return l <= x && x <= r;
}
template <typename _Tp>
inline _Tp sqr(_Tp x) {
  return x * x;
}
template <typename _Tp>
inline _Tp power(_Tp x, int64 m) {
  return m == 1 ? x : (m & 1 ? power(x * x, m / 2) * x : power(x * x, m / 2));
}
template <typename _Tp>
inline void sort(_Tp &x, _Tp &y) {
  if (x > y) std::swap(x, y);
}
template <typename _Tp1, typename _Tp2>
inline std::pair<_Tp1, _Tp2> operator+(std::pair<_Tp1, _Tp2> x,
                                       std::pair<_Tp1, _Tp2> y) {
  return x.first += y.first, x.second += y.second, x;
}
template <typename _Tp>
_Tp &operator+=(_Tp &x, _Tp y) {
  return x = x + y;
}
}  // namespace oct
const int C = 20;
const int INF = 0x3f3f3f3f;
const int mod = 741923771;
int readS();
char s[C];
int n, k, x, ans;
int64 w, tmp;
inline int readS() {
  std::cin >> s;
  if (s[0] == '?') return INF;
  int x = 0, f = 0;
  if (s[0] == '-') f = 1;
  for (int i = s[0] == '-'; s[i]; ++i) x = x * 10 + (s[i] - '0');
  return f ? -x : x;
}
int main() {
  oct::sync();
  std::cin >> n >> k;
  if (!k) {
    x = readS(), ans += x == INF;
    for (int i = 1; i <= n; ++i) ans += readS() == INF;
    ans = !x || x == INF && (n + 1 - ans) & 1;
  } else {
    tmp = 1;
    for (int i = 0; i <= n; ++i) {
      ans += (x = readS()) == INF;
      w = (w + x * tmp) % mod;
      tmp = tmp * k % mod;
    }
    ans = ans && n & 1 || !w;
  }
  std::cout << (ans ? "Yes" : "No") << std::endl;
  return 0;
}
