#include <iostream>
#include <stdlib.h>
#include <vector> //vector
#include <algorithm> //sort()
#include <numeric>
#include <tuple>

#define rep(i, n) for(int i=0; i<(int)(n);i++)
#define all(x) (x).begin(), (x).end()
#define debug(a) cout << "debug (" #a "):" << endl << (a) << endl;

typedef uint64_t ulint;
typedef int64_t lint;

using namespace std;

template<class T> inline bool chmin(T& a, T b);
template<class T> inline bool chmax(T& a, T b);
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v);

template<class T> lint sum(vector<T> a);
template<class T> double ave(vector<T> a);

lint n, k;
lint h, w;

// int vector_finder(std::vector<lint> vec, lint number) {
//   auto itr = std::find(vec.begin(), vec.end(), number);
//   size_t index = std::distance( vec.begin(), itr );
//   if (index != vec.size()) { // 発見できたとき
//     return 1;
//   }
//   else { // 発見できなかったとき
//     return 0;
//   }
// }



int main(){
//////////////////////////////////////////////////////

    cin >> n;
    vector<ulint> a(n);
    //fpair<lint,lint> p = make_pair(1,2);
    //tuple<lint,lint,lint> t  = make_tuple(1,2,3);

    rep(i,n)
    {
        cin >> a[i];
    }

    sort(a.begin() , a.end());

    if(a[n-1] == 0)
    {
        cout << "Yes" << endl;
        return 0;
    }

    
    bool success = false;
    
    //vector<ulint> b(n);
    // vector<lint> used(n,0);

    lint c1,c2,c3;


    if(n%3==0)
    {
        c1 = a[0];
        //debug(c1);

        auto itr = lower_bound(a.begin(), a.end(), c1 + 1);
        size_t pos = std::distance(a.begin(), itr);
        if(pos!= n && n == pos * 3)
        {
            
            c2 = a[pos];
            //debug(pos);
            //debug(c2);
            itr = lower_bound(a.begin(), a.end(), c2 + 1);
            pos = std::distance(a.begin(), itr);
            //debug(pos);
            //debug(a[pos]);

            if(itr == a.end() && c1==0)
            {
                cout << "Yes" << endl;
                return 0;
            }

            if(pos!= n && n * 2 == pos * 3 )
            {
                c3 = a[pos];
                //debug(c3);
                itr = lower_bound(a.begin(), a.end(), c3 + 1);
                
                if(itr == a.end() && (c1^c2) == c3)
                {
                    
                    cout << "Yes" << endl;
                    return 0;
                }
            }
        }



    }
    cout << "No" << endl;

    // //2個目を適当に配置
    // for(lint i=1; i<n ; i++)
    // {
    //     //debug(i);
    //     ulint sum = a[0]; //1こめは常にこれ
    //     b[0] = a[0];
    //     used[0] = 0;

    //     sum^=a[i];
    //     used[i] = 0;
    //     b[1]=a[i];
        

    //     ulint left = b[0] ^ b[1];



    //     lint cnt = 2;
    //     for(lint j=2;j<n;j++)//残りを配置していくループ
    //     {
    //         auto itr = lower_bound(a.begin(), a.end(), b[j-2]^b[j-1]);
            
    //         if(itr == a.end() || *itr != (b[j-2]^b[j-1]))
    //         {
    //             break;
    //         }
    //         size_t pos = std::distance(a.begin(), itr);
    //         if(used[pos]!=0)
    //         {
    //             pos+=used[pos];
    //             used[pos]++;
                
    //         }
    //         // while(used[pos] == true)
    //         // {
    //         //     if(a[pos] != (b[j-2]^b[j-1]))break;
    //         //     pos++;
    //         // }
    //         // if(a[pos] == (b[j-2]^b[j-1]) && used[pos]==false )
    //         // {
    //         //     b[2]=a[pos];
    //         //     used[pos] = true;
    //         // }
    //         if(a[pos] == (b[j-2]^b[j-1])  && used[pos]==0 )
    //         {
    //             b[2]=a[pos];
    //             used[pos]++;
    //         }
    //         else
    //         {
    //             break;
    //         }
    //         if(j == n - 1 && b[j]==left)
    //         {
    //             success = true;
    //             cout << "Yes" << endl;
    //             break;
    //         }
    //     }

    //     if(success)break;
    // }
    // if(!success)
    // {
    //     cout << "No" << endl;
    // }


    //昇順ソート
    //sort(all(a));

   



    // uint64_t max = numeric_limits<uint64_t>::max();


    //////////////////////////////////////////////////////
    // DP

//     // 無限大の値
//     const uint64_t INF = (uint64_t)1 << 60;
//     //const int64_t NINF = -1 * ((int64_t)1 << 60 );
 
//     // DP テーブル
//     uint64_t dp[100010];

//     //DPテーブル初期化（最小化用）
//     for (int i = 0; i < 100010; ++i)
//     {
//         //dp[i] = INF;
//         dp[i] = 0;
//     } 

//     // 初期条件
//     dp[0] = 0;

//     // ループ
//     for (int i = 1; i <= n; ++i) {
//         //chmin( dp[i], dp[i - 1] + abs( input[i] - input[i - 1] ));
//         //if (i < 2)continue;
//         //chmin( dp[i], dp[i - 2] + abs( input[i] - input[i - 2] ));



//         // chmax ( dp [i] , dp[i - 1]);
//         // chmax ( dp [i] , dp[i - 1] + input[i]);
//         // cout << "dp[" << i <<"] = " << dp[i] << endl;

//     }



// //////////////////////////////////////////////////////

//     cout << dp[n] << endl;

//////////////////////////////////////////////////////
// Ctrl + Opt + N to make
    return 0;
}




//最小化用関数
template<class T> inline bool chmin(T& a, T b)
{
    if (a > b) 
    {
        a = b;
        return true;
    }
    return false;
}

//最大化関数
template<class T> inline bool chmax(T& a, T b)
{
    if (a < b)
    {
        a = b;
        return true;
    }
    return false;
}


// vectorprint用
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
	int len = v.size();
	for (int i = 0; i < len; ++i) {
		s << v[i]; if (i < len - 1) s << "\t";
	}
	return s;
}

// //合計
// template<class T> lint sum(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0);
// }


// //平均
// template<class T> double ave(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0.0) / a.size();
// }


Measured memory_bytes: 1024