#include<bits/stdc++.h>
#include<atcoder/all>
#define rep(i,b) for(int i=0;i<b;i++)
#define rrep(i,b) for(int i=b-1;i>=0;i--)
#define rep1(i,b) for(int i=1;i<b;i++)
#define repx(i,x,b) for(int i=x;i<b;i++)
#define rrepx(i,x,b) for(int i=b-1;i>=x;i--)
#define fore(i,a) for(auto& i:a)
#define rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define pb push_back
#define fi first
#define se second
#define pcnt __builtin_popcountll

using namespace std;
using namespace atcoder;

using ll = long long;
using ld = long double;
template<typename T> using mpq = priority_queue<T, vector<T>, greater<T>>;
template<typename T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<typename T> bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<typename T> ll sumv(const vector<T>&a){ll res(0);for(auto&&x:a)res+=x;return res;}
bool yn(bool a) { if(a) {cout << "Yes" << endl; return true;} else {cout << "No" << endl; return false;}}
#define retval(x) {cout << #x << endl; return;}
#define cout2(x,y) cout << x << " " << y << endl;
#define coutp(p) cout << p.fi << " " << p.se << endl;
#define out cout << ans << endl;
#define outd cout << fixed << setprecision(20) << ans << endl;
#define outm cout << ans.val() << endl;
#define outv fore(yans , ans) cout << yans << "\n";
#define outdv fore(yans , ans) cout << yans.val() << "\n";
#define assertmle(x) if (!(x)) {vi v(3e8);}
#define asserttle(x) if (!(x)) {while(1){}}
#define coutv(v) {fore(vy , v) {cout << vy << " ";} cout << endl;}
#define coutv2(v) fore(vy , v) cout << vy << "\n";
#define coutvm(v) {fore(vy , v) {cout << vy.val() << " ";} cout << endl;}
#define coutvm2(v) fore(vy , v) cout << vy.val() << "\n";
using pll = pair<ll,ll>;using pil = pair<int,ll>;using pli = pair<ll,int>;using pii = pair<int,int>;using pdd = pair<ld,ld>;
using vi = vector<int>;using vd = vector<ld>;using vl = vector<ll>;using vs = vector<string>;using vb = vector<bool>;
using vpii = vector<pii>;using vpli = vector<pli>;using vpll = vector<pll>;using vpil = vector<pil>;
using vvi = vector<vector<int>>;using vvl = vector<vector<ll>>;using vvs = vector<vector<string>>;using vvb = vector<vector<bool>>;
using vvpii = vector<vector<pii>>;using vvpli = vector<vector<pli>>;using vvpll = vector<vpll>;using vvpil = vector<vpil>;
using mint = modint998244353;
//using mint = modint1000000007;
//using mint = dynamic_modint<0>;
using vm = vector<mint>;
using vvm = vector<vector<mint>>;
vector<int> dx={1,0,-1,0,1,1,-1,-1},dy={0,1,0,-1,1,-1,1,-1};
ll gcd(ll a, ll b) { return a?gcd(b%a,a):b;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
#define yes {cout <<"Yes"<<endl;}
#define no {cout <<"No"<<endl;}
const double eps = 1e-10;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#ifdef MY_LOCAL_DEBUG
#include "./debug/localDebug.cpp"
#define showp(p) cerr<<#p<<" = "<<p.fi<<" : "<<p.se<<endl
#define show1(a) cerr<<#a<<" = "<<a<<endl
#define show2(a,b) cerr<<#a<<" = "<<a<<" : "<<#b<<" = "<<b<<endl
#define show3(a,b,c) cerr<<#a<<" = "<<a<<" : "<<#b<<" = "<<b<<" : "<<#c<<" = "<<c<<endl
#define show4(a,b,c,d) cerr<<#a<<" = "<<a<<" : "<<#b<<" = "<<b<<" : "<<#c<<" = "<<c<<" : "<<#d<<" = "<<d<<endl
#define show5(a,b,c,d,e) cerr<<#a<<" = "<<a<<" : "<<#b<<" = "<<b<<" : "<<#c<<" = "<<c<<" : "<<#d<<" = "<<d<<" : "<<#e<<" = "<<e<<endl
#define DEBUG_LINE cout << "DEBUG_LINE : " << __LINE__ << endl
#define showv(v) {cout<<#v<<" : "; fore(vy , v) {cout << vy << " ";} cout << endl;}
#define showv2(v) {cout<<#v<<endl; fore(vy , v) cout << vy << "\n";}
#define showvm(v) {cout<<#v<<" : "; fore(vy , v) {cout << vy.val() << " ";} cout << endl;}
#define showvm2(v) {cout<<#v<<endl; fore(vy , v) cout << vy.val() << "\n";}
#define showmat(v) {cout<<#v<<endl; fore(row , v) { fore(seg , row) cout << seg << " "; cout << endl;}}
#define showmatm(v) {cout<<#v<<endl; fore(row , v) { fore(seg , row) cout << seg.val() << " "; cout << endl;}}
#else
#define showp(p)
#define show1(a)
#define show2(a,b)
#define show3(a,b,c)
#define show4(a,b,c,d)
#define show5(a,b,c,d,e)
#define DEBUG_LINE
#define showv(v)
#define showv2(v)
#define showvm(v)
#define showvm2(v)
#define showmat(v)
#define showmatm(v)
#endif
#define overload5(a,b,c,d,e,f, ...) f
#define show(...) overload5(__VA_ARGS__, show5, show4, show3, show2, show1)(__VA_ARGS__)

template <typename T, int MAX_LOG, int NODES = 10000000>
struct BinaryTrie
{
    using Container = vector<int>;
    struct Node
    {
        Node *nxt[2];
        int exist;
        Container accept;
        Node() {}
    };
    
    Node *pool;
    int pid;
    T lazy;
    Node *nil;
    Node *root;
    int num;
    
    BinaryTrie() : pid(0), lazy(T(0)), nil(nullptr), num(0)
    {
        pool = new Node[NODES];
        nil = my_new();
        nil->nxt[0] = nil->nxt[1] = root = nil;
    }

    Node *my_new(int exist_ = 0, int id = -1)
    {
        pool[pid].nxt[0] = pool[pid].nxt[1] = nil;
        pool[pid].exist = exist_;
        if (id != -1)
            pool[pid].accept.push_back(id);
        return &(pool[pid++]);
    }

    Node *merge(Node *l, Node *r)
    {
        pool[pid].nxt[0] = l;
        pool[pid].nxt[1] = r;
        pool[pid].exist = l->exist + r->exist;
        return &(pool[pid++]);
    }

private:
    Node *add_(const T &x, int id, Node *n, int bit_idx)
    {
        if (bit_idx == -1)
        {
            if (n == nil)
                return my_new(1, id);
            n->exist++;
            n->accept.push_back(id);
            return n;
        }
        else
        {
            if (((lazy >> bit_idx) & 1) == ((x >> bit_idx) & 1))
                return merge(add_(x, id, n->nxt[0], bit_idx - 1), n->nxt[1]);
            else
                return merge(n->nxt[0], add_(x, id, n->nxt[1], bit_idx - 1));
        }
    }

public:
    void add(const T &x, int id = -1)
    {
        assert(x >= 0);
        num++;
        assert(num < NODES);
    
        root = add_(x, id, root, MAX_LOG);
    }

private:
    pair<int, Container &> find_(const T &x, Node *n, int bit_idx)
    {
        if (bit_idx == -1)
            return pair<int, Container &>(n->exist, n->accept);
        else
        {
            if (((lazy >> bit_idx) & 1) == ((x >> bit_idx) & 1))
                return find_(x, n->nxt[0], bit_idx - 1);
            else
                return find_(x, n->nxt[1], bit_idx - 1);
        }
    }

public:
    pair<int, Container &> find(const T &x) { return find_(x, root, MAX_LOG); }

private:
    Node *del_(const T &x, int id, Node *n, int bit_idx)
    {
        if (bit_idx == -1)
        {
            n->exist--;
            return n;
        }
        else
        {
            if (((lazy >> bit_idx) & 1) == ((x >> bit_idx) & 1))
                return merge(del_(x, id, n->nxt[0], bit_idx - 1), n->nxt[1]);
            else
                return merge(n->nxt[0], del_(x, id, n->nxt[1], bit_idx - 1));
        }
    }

public:
    void del(const T &x, int id = -1)
    {
        num--;
        assert(find(x).fi != 0);
        root = del_(x, id, root, MAX_LOG);
    }

private:
    pair<T, Container &> max_element_(Node *n, int bit_idx)
    {
        if (bit_idx == -1)
            return pair<T, Container &>(0, n->accept);
        if (n->nxt[~(lazy >> bit_idx) & 1]->exist)
        {
            auto ret = max_element_(n->nxt[~(lazy >> bit_idx) & 1], bit_idx - 1);
            ret.first |= T(1) << bit_idx;
            return ret;
        }
        else
        {
            return max_element_(n->nxt[(lazy >> bit_idx) & 1], bit_idx - 1);
        }
    }

public:
    pair<T, Container &> max_element()
    {
        assert(num > 0);
        return max_element_(root, MAX_LOG);
    }

private:
    pair<T, Container &> min_element_(Node *n, int bit_idx)
    {
        if (bit_idx == -1)
            return pair<T, Container &>(0, n->accept);
        if (n->nxt[(lazy >> bit_idx) & 1]->exist)
        {
            return min_element_(n->nxt[(lazy >> bit_idx) & 1], bit_idx - 1);
        }
        else
        {
            auto ret = min_element_(n->nxt[~(lazy >> bit_idx) & 1], bit_idx - 1);
            ret.first |= T(1) << bit_idx;
            return ret;
        }
    }

public:
    pair<T, Container &> min_element()
    {
        assert(num > 0);
        return min_element_(root, MAX_LOG);
    }

private:
    pair<T, Container &> get_kth_(Node *n, int64_t k, int bit_idx)
    {
        if (bit_idx == -1)
            return pair<T, Container &>(0, n->accept);
        int ex0 = n->nxt[(lazy >> bit_idx) & 1]->exist;
        if (ex0 < k)
        {
            auto ret = get_kth_(n->nxt[~(lazy >> bit_idx) & 1], k - ex0, bit_idx - 1);
            ret.first |= T(1) << bit_idx;
            return ret;
        }
        else
        {
            return get_kth_(n->nxt[(lazy >> bit_idx) & 1], k, bit_idx - 1);
        }
    }

public:
    pair<T, Container &> get_kth(int64_t k)
    {
        assert(k < num);
        return get_kth_(root, k + 1, MAX_LOG);
    }

    void operate_xor(T x) { lazy ^= x; }
};

// BinaryTrie<T,LogMax, int NODES = 18000000> trie : 宣言方法。
//   addする要素の数をnとしたとき n * LogMax < NODES となるように。MLE注意。インスタンスを複数用意する場合はNODESを小さくする。
// add(x , id) : idをインデックスとしてもつxを木に追加
// del(x , id) : idをインデックスとしてもつxを木から削除
// find(x) : 木にxが存在するかどうか。返り値はpair(個数,インデックスの集合)
// max_element()/min_element() : 最大値/最小値を返す。返り値はpair(最大値/最小値,インデックスの集合)
// get_kth() : k番目(0-Origin & 昇順)の値を返す。返り値はpair(値,インデックスの集合)
// operate_xor(x) : 集合全体にxorを作用させる。

// 配列外アクセスは全てアサートが出る。
// インデックスの集合はvi型で受け取れる。

void solve(){
    int n,k; cin>>n>>k;
    vi a(n);
    rep(i,n) cin>>a[i];
    
    map<int,int> mp;
    int lmx = -1;
    int rmn = INF;
    mp[0] = 0;
    int s = 0;
    rep(i,n){
        s ^= a[i];
        if (mp.count(s)){
            chmax(lmx, mp[s]);
            chmin(rmn, i);
        }
        mp[s] = i+1;
    }

    BinaryTrie<int,20> bt;
    s = 0;
    rep1(i,n){
        s ^= a[i];
        bt.add(s);
    }
    multiset<int> rs,ls;
    vi rsum(n),lsum(n);
    auto upd = [&](int id)->void{
        if (id >= n-1) return; 
        bt.operate_xor(a[id]);
        bt.operate_xor(a[id+1]);
        ls.insert(lsum[id]);
        if (id < n-1){
            auto it = rs.lower_bound(rsum[id+1]);
            rs.erase(it);
        }
    };
    rep(i,n){
        lsum[i] = a[i];
        if (i) lsum[i] ^= lsum[i-1];
    }
    rrep(i,n){
        rsum[i] = a[i];
        if (i<n-1) rsum[i] ^= rsum[i+1];
    }
    auto isOK = [&](int x)->bool{
        if (x <= 0) return false;
        if (ls.find(x) != ls.end()) return false;
        if (rs.find(x) != rs.end()) return false;
        int k = bt.find(x).fi;
        return k == 0;
    };

    rep1(i,n) rs.insert(rsum[i]);

    bool ok = false;
    rep(i,n){
        if (i < lmx || i > rmn){
            upd(i);
            continue;
        }
        rep(j,k+1){
            int k1 = a[i] + j;
            int k2 = a[i] - j;
            if (isOK(k1)) ok = true;
            if (isOK(k2)) ok = true;
        }
        upd(i);
    }
    yn(ok);

    return;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);

    int t = 1;
    //cin>>t;

    rep(i,t){
        solve();
    }

    return 0;
}