Problem:
Score : 400 points

Problem Statement

We have N integers. The i-th integer is A_i.

Find \sum_{i=1}^{N-1}\sum_{j=i+1}^{N} (A_i \mbox{ XOR } A_j), modulo (10^9+7).

What is \mbox{ XOR }?

The XOR of integers A and B, A \mbox{ XOR } B, is defined as follows:

When A \mbox{ XOR } B is written in base two, the digit in the 2^k's place (k \geq 0) is 1 if either A or B, but not both, has 1 in the 2^k's place, and 0 otherwise.

For example, 3 \mbox{ XOR } 5 = 6. (In base two: 011 \mbox{ XOR } 101 = 110.)

Constraints

2 \leq N \leq 3 \times 10^5

0 \leq A_i < 2^{60}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the value \sum_{i=1}^{N-1}\sum_{j=i+1}^{N} (A_i \mbox{ XOR } A_j), modulo (10^9+7).

Sample Input 1

3
1 2 3

Sample Output 1

6

We have (1\mbox{ XOR } 2)+(1\mbox{ XOR } 3)+(2\mbox{ XOR } 3)=3+2+1=6.

Sample Input 2

10
3 1 4 1 5 9 2 6 5 3

Sample Output 2

237

Sample Input 3

10
3 14 159 2653 58979 323846 2643383 27950288 419716939 9375105820

Sample Output 3

103715602

Print the sum modulo (10^9+7).

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::cmp::{max, min};
use std::io::{stdin, stdout, BufWriter, Write};

const K: usize = 60;
const MOD: i64 = 1e9 as i64 + 7;

fn i64_to_bit_vec(x: i64) -> Vec<i64> {
    let mut ret: Vec<i64> = vec![];
    for i in 0..K {
        ret.push(x >> i & 1);
    }
    ret
}

fn main() {
    /* START INIT IO */
    let stdin_obj = stdin();
    let mut scan = Scanner {
        stdin: stdin_obj.lock(),
    };
    let out = &mut BufWriter::new(stdout());
    /* END INIT IO */

    // Code starts here
    let n: usize = scan.read();
    let a: Vec<i64> = scan.read_vec(n);
    let mut cnt_1: [i64; K] = [0; K];

    for i in 0..a.len() {
        let curr_bit_vec = i64_to_bit_vec(a[i]);
        for j in 0..K {
            if curr_bit_vec[j] == 1 {
                cnt_1[j] += 1;
            }
        }
    }

    let mut p: i64 = 1;
    let mut res: i64 = 0;
    for j in 0..K {
        let total_pairs = cnt_1[j] * (n as i64 - cnt_1[j]) % MOD;
        res += total_pairs * p % MOD;
        res %= MOD;
        p <<= 1;
        p %= MOD;
    }

    writeln!(out, "{}", res).ok();
}

/* IO SNIPPET */
/*
Example uses:
let n: usize = scan.read();
let k: i64 = scan.read();
let mut a: Vec<i64> = scan.vec(n);
wri teln!(out, "{}", l).ok();
*/

#[derive(Default)]
pub struct Scanner<R> {
    stdin: R,
}
impl<R: std::io::Read> Scanner<R> {
    // Reads single token
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    // Reads whole line
    pub fn read_line(&mut self) -> String {
        use std::io::Read;
        let buf = self
            .stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b'\n' || b == b'\r')
            .take_while(|&b| b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    // Reads a vector with elements of type T by token (uses self.read to read)
    pub fn read_vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    // Read token but returns Vec<char> instead of inferred type
    pub fn read_chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}