using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

public class ABC
{
    //          long[] sp = Console.ReadLine().Split().Select(long .Parse).ToArray();
    //          int[] sp = Console.ReadLine().Split().Select(int.Parse).ToArray();
    public static void Main()
    {
        int N = int.Parse(Console.ReadLine());
        long[] a = Console.ReadLine().Split().Select(long.Parse).ToArray();
        long[] camels = new long[N];
        //0,0,0;
        if (a.Sum() == 0)
        {
            Console.WriteLine("Yes");
        }
        else if (N % 3 != 0)
        {
            Console.WriteLine("No");

        }
        else
        {
            List<long> keys = new List<long>();
            Dictionary<long, long> capInfo = new Dictionary<long, long>();
            for (int i = 0; i < N; i++)
            {
                if (capInfo.ContainsKey(a[i]))
                {
                    capInfo[a[i]] += 1;
                }
                else
                {
                    capInfo[a[i]] = 1;
                    keys.Add(a[i]);
                }
            }

            if (keys.Count == 2)
            {
                long key_smaller = keys[0];
                long key_bigger = keys[1];
                if (key_smaller > key_bigger)
                {
                    long temp = key_bigger;
                    key_bigger = key_smaller;
                    key_smaller = temp;
                }
                long value_smaller = capInfo[key_smaller];
                long value_bigger = capInfo[key_bigger];
                if (key_smaller != 0)
                {
                    Console.WriteLine("No");

                }
                else
                {
                    if (value_smaller * 2 == value_bigger)
                    {
                        Console.WriteLine("Yes");
                    }
                    else
                        Console.WriteLine("No");
                }

            }
            else if (keys.Count == 3)
            {
                long key1 = keys[0];
                long key2 = keys[1];
                long key3 = keys[2];
                long value1 = capInfo[key1];
                long value2 = capInfo[key2];
                long value3 = capInfo[key3];

                if ((key1 ^ key2) != key3)
                {
                    Console.WriteLine("No");
                }
                else if (value1 == value2 && value2 == value3)
                {
                    Console.WriteLine("Yes");
                }
                else
                {
                    Console.WriteLine("No");
                }

            }
            else
            {
                Console.WriteLine("No");

            }

        }
        
        //0,M,M
        //1,6,7系


    }




}

class CapState
{
    public int N;
    public int[] camels;
    public int decided = 0;
    public CapState()
    {
    }
    public CapState(int N, int[] camels)
    {
        this.decided = 0;
        this.N = N;
        this.camels = camels;
    }
}




class Util
{
    public static long GCD(long a, long b)
    {
        if (a < b)
            swap(ref a, ref b);
        if (a % b == 0) return b;
        return GCD(b, a % b);

    }
    public static int GCD(int a, int b)
    {
        if (a < b)
            swap(ref a, ref b);
        if (a % b == 0) return b;
        return GCD(b, a % b);
    }

    public static void swap<T>(ref T a,ref T b)
    {
        T temp = b;
        b = a;
        a = temp;

    }
    public static long LCM(long a, long b)
    {
        return a * b / GCD(a, b);
    }
    public static long LCM(int a, int b)
    {
        return Math.BigMul(a, b) / GCD(a, b);
    }


    private static int M = 1000000007;
    private static int[] factorial_modM;
    public static int Multiple_modM(int a, int b)
    {
        return (int)(Math.BigMul(a, b) % M);
    }
    public static void factorial_modM_Prepare(int n)
    {
        factorial_modM = new int[n + 1];
        factorial_modM[0] = 1;
        for (int i = 1; i <= n; ++i)
        {
            factorial_modM[i] = Multiple_modM(factorial_modM[i - 1], i);
        }
    }
    public static int Factorial(int n)
    {
        return factorial_modM[n];
    }
    public static int Pow(int a, int m)
    {
        switch (m)
        {
            case 0:
                return 1;
            case 1:
                return a;
            default:
                int p1 = Pow(a, m / 2);
                int p2 = Multiple_modM(p1, p1);
                return ((m % 2) == 0) ? p2 : Multiple_modM(p2, a);
        }
    }
    public static int Div(int a, int b)
    {
        return Multiple_modM(a, Pow(b, M - 2));
    }
    public static int nCr_modM(int n, int r)
    {
        if (n < r) { return 0; }
        if (n == r) { return 1; }
        int res = Factorial(n);
        res = Div(res, Factorial(r));
        res = Div(res, Factorial(n - r));
        return res;
    }

}

class UnionFind<T>
{
    public int tree_height;
    public UnionFind<T> parent;
    public T item
    {
        get;
        private set;
    }

    public UnionFind(T item)
    {
        tree_height = 0;
        parent = this;
    }

    public UnionFind<T> FindAdam()
    {
        if (parent == this) return this;
        else
        {
            UnionFind<T> ParentOfParent = parent.FindAdam();
            parent = ParentOfParent;//縦長な構成をつなぎ直している
            return ParentOfParent;
        }
    }
    public static void Unite(UnionFind<T> a, UnionFind<T> b)
    {
        UnionFind<T> ParentOfA = a.FindAdam();
        UnionFind<T> ParentOfB = b.FindAdam();
        if (ParentOfA.tree_height < ParentOfB.tree_height)
        {
            ParentOfA.parent = ParentOfB;
            ParentOfB.tree_height = Math.Max(ParentOfA.tree_height + 1, ParentOfB.tree_height);
        }
        else
        {
            ParentOfB.parent = ParentOfA;
            ParentOfA.tree_height = Math.Max(ParentOfB.tree_height + 1, ParentOfA.tree_height);
        }

    }

}

static class Permutation<T>
{
    private static void Search(List<T[]> perms, Stack<T> stack, T[] a)
    {
        int N = a.Length;
        if (N == 0)
        {
            perms.Add(stack.Reverse().ToArray());
        }
        else
        {
            var b = new T[N - 1];
            Array.Copy(a, 1, b, 0, N - 1);
            for (int i = 0; i < a.Length; ++i)
            {
                stack.Push(a[i]);
                Search(perms, stack, b);
                if (i < b.Length) { b[i] = a[i]; }
                stack.Pop();
            }
        }
    }
    public static IEnumerable<T[]> All(IEnumerable<T> src)
    {
        var perms = new List<T[]>();
        Search(perms, new Stack<T>(), src.ToArray());
        return perms;
    }
}

Measured memory_bytes: 31584