#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
template <class T>
bool ckmin(T& a, const T& b) {
  return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0;
}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
constexpr auto hasBegin(int) -> decltype(std::begin(std::declval<T>()), true) {
  return true;
}
constexpr bool hasBegin(...) { return false; }
template <typename T>
using IsContainer = std::integral_constant<bool, hasBegin<T>(0)>;
template <typename T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
  for (T& element : vec) {
    is >> element;
  }
  return is;
}
template <typename T, typename U>
std::istream& operator>>(std::istream& is, std::pair<T, U>& p) {
  is >> p.first;
  is >> p.second;
  return is;
}
template <class X, class Y>
std::ostream& operator<<(std::ostream& os, std::pair<X, Y> const& p) {
  return os << p.first << " " << p.second;
}
template <class Ch, class Tr, class Container>
std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& os,
                                       Container const& x) {
  bool first = true;
  for (auto& y : x) {
    if (first) {
      first = false;
    } else {
      os << " ";
    }
    os << y;
  }
  return os;
}
using namespace std;
class AXORCircle {
 public:
  void solve(std::istream& in, std::ostream& out) {
    int n;
    in >> n;
    vector<int> A(n);
    in >> A;
    bool res = false;
    if (count(begin(A), end(A), 0) == n) {
      res = true;
    } else if (n % 3 == 0) {
      sort(begin(A), end(A));
      res = (A[0] ^ A[n / 3]) == A[2 * n / 3];
      for (int i = (0); i < (n); ++i) {
        if (A[i] != A[i * 3 / n]) {
          res = false;
        }
      }
    }
    out << (res ? "Yes" : "No") << '\n';
  }
  void setup() {}
};
int main() {
  std::ios_base::sync_with_stdio(false);
  AXORCircle solver;
  solver.setup();
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  in.tie(nullptr);
  out << std::fixed;
  out.precision(20);
  solver.solve(in, out);
  return 0;
}
