use std::io::*;

const SP: u8 = b' ';
const LF: u8 = b'\n';

struct CharacterInput<'a> {
    locked_stdin: StdinLock<'a>,
    bytes_buffer: Vec<u8>,
}

impl<'a> CharacterInput<'a> {
    fn read(&mut self, delimiter: u8) -> &[u8] {
        self.bytes_buffer.clear();

        let mut len = self
            .locked_stdin
            .read_until(delimiter, &mut self.bytes_buffer)
            .unwrap();

        if len > 0 {
            len -= 1;
        }

        &self.bytes_buffer[0..len]
    }

    fn scan_u(&mut self, delimiter: u8) -> u32 {
        self.read(delimiter)
            .into_iter()
            .fold(0, |accumulator, byte| {
                (byte - b'0') as u32 + accumulator * 10
            })
    }

    fn scan_u_vec(&mut self, n: usize, separator: u8, delimiter: u8) -> Vec<u32> {
        let mut vector = Vec::with_capacity(n as usize);
        for _i in 0..n - 1 {
            vector.push(self.scan_u(separator));
        }
        vector.push(self.scan_u(delimiter));
        vector
    }
}

fn create_cin<'a>(input: StdinLock<'a>, buffer_capacity: usize) -> CharacterInput {
    CharacterInput {
        locked_stdin: input,
        bytes_buffer: Vec::with_capacity(buffer_capacity),
    }
}

// easy
fn println<T: std::string::ToString>(s: T) {
    println!("{}", s.to_string());
}

// ------------------------------------------------------------------------

fn main() {
    let cin = stdin();
    let cin = &mut create_cin(cin.lock(), 32);

    let n = cin.scan_u(LF) as usize;
    let a = cin.scan_u_vec(n, SP, LF);

    let mut checked: Vec<bool> = vec!(false; n);
    let mut vec: Vec<u32> = Vec::new();

    vec.push(a[0]);
    checked[0] = true;

    'outer: for i in 1..a.len() - 1 {
        for k in i + 1..a.len() {
            if a[i] == a[0] ^ a[k] {
                checked[i] = true;
                vec.push(a[i]);
                checked[k] = true;
                vec.push(a[k]);
                break 'outer;
            }
        }
    }

    if vec.len() < 3 {
        println("No");
        return;
    }

    while vec.len() < n {
        for i in 1..n {
            if checked[i] { continue; }

            if vec[vec.len() - 1] == vec[vec.len() - 2] ^ vec[i] {
                vec.push(a[i]);
                checked[i] = true;
                break;
            }
        }
    }

    if vec[vec.len() - 1] == vec[vec.len() - 2] ^ vec[0] {
        println("Yes");
    } else {
        println("No");
    }

    // println!("{:?}", vec);
}
