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 (Python):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''

import numpy as np
i8 = np.int64
i4 = np.int32

def main2():
    stdin = open('/dev/stdin')
    N = int(stdin.readline())
    x = np.zeros(60, i8)
    for d in map(int, stdin.readline().split()):
        for j in range(x.shape[0]):
            if d & 1:
                x[j] += 1
            d >>= 1
    ans = 0
    for i in range(x.shape[0] - 1, -1, -1):
        ans = (ans * 2 + x[i] * (N - x[i])) % 1000000007
    print(ans)

'''

Solution (Python):
n = int(input())
A = list(map(int, input().split()))

mod = 10**9 + 7
total = 0
for i in range(60):
  cnt = sum([1 for a in A if (a>>i & 1)])
  total += cnt * (n-cnt) * (1 << i)
  total %= mod
print(total)

Solution (Python):
def solve(a_s) -> int:
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  
  
  zeros = [0] * 60

  ret = 0
  for i in range(60):
    ones = sum([(a >> i) & 0b1 for a in a_s])
    ret += 2**i * (ones * (len(a_s) - ones))
    ret %= 10**9 + 7
  return ret

  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  


n = int(input().strip())
a_s = [int(s) for s in input().split()]





print(solve(a_s))

Solution (Python):
import sys


def main():
    n = int(sys.stdin.readline().strip())
    a = [int(s) for s in sys.stdin.readline().strip().split(' ')]
    b = []

    maxlen = -1
    for i in range(n):
        ai = a[i]
        bi = format(ai, 'b')
        b.append(bi)
        if maxlen < len(bi):
            maxlen = len(bi)

    ans = 0
    for i in range(maxlen):
        ones = 0
        zeros = 0
        for j in range(n):
            if len(b[j]) < i + 1:
                zeros += 1
            else:
                target = b[j][-1-i]
                if target == '1':
                    ones += 1
                else:
                    zeros += 1
        ans += (2 ** i) * (ones * zeros)
        ans = ans % (10 ** 9 + 7)
    print(ans)


main()

Solution (Python):
import sys
sys.setrecursionlimit(1000000000)
from itertools import count
from functools import lru_cache
from collections import defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok


def main():
    N = ii()
    S1 = [0] * 100
    for a in mis():
        b = 1
        for i in count():
            if b > a:
                break
            if a & b:
                S1[i] += 1
            b <<= 1
    ans = 0
    b = 1
    for i in range(len(S1)):
        s1 = S1[i]
        s0 = N - s1
        ans += (s1*s0) * (b%N1097)
        ans %= N1097
        b <<= 1

    print(ans)




main()

Solution (Python):
n,*a=map(int,open(0).read().split())
c=0
for i in range(61):t=sum(2**i&b>0for b in a);c+=t*(n-t)*2**i
print(c%(10**9+7))

Solution (Python):
n,*a=map(int,open(0).read().split())
c=0
for i in range(61):t=sum(2**i&b>0for b in a);c=(c+t*(n-t)*2**i)%(10**9+7)
print(c)

Solution (Python):
n,*a=map(int,open(0).read().split())
c=0
for i in range(61):
  i=2**i
  t=sum(i&b and 1for b in a)
  c=(c+t*(n-t)*i)%(10**9+7)
print(c)

Solution (Python):
def main():
  n,*a=map(int,open(0).read().split())
  c=0
  for i in range(61):
    i=2**i
    t=sum(i&b and 1for b in a)
    c=(c+t*(n-t)*i)%(10**9+7)
  print(c)
main()

Solution (Python):
n,*a=map(int,open(0).read().split())
b=[0]*61
for c in a:
  for i in range(61):b[i]+=2**i&c>0
print(sum(2**i*c*(n-c)for i,c in enumerate(b))%(10**9+7))

Solution (Python):
import sys
input=sys.stdin.readline

N=int(input())
A=tuple(map(int,input().split()))

mod=10**9+7
X=[0]*61
for x in A:
    i=0
    while x!=0:
        X[i]+=x&1
        x>>=1
        i+=1
ans=0
for x in A:
    x%=mod
    ans=(ans+x)%mod
ans=(ans*(N-1))%mod

for c,x in enumerate(X):
    if x>=2:ans=(ans-(x*(x-1)%mod)*pow(2,c,mod))%mod
print(ans)

Solution (Python):
n=int(input())
l=sorted(list(map(int,input().split())))
num=l[-1]
b1=[]

while num!=0:
  b1.append(num%2)
  num//=2
d={}
for i in range(len(b1)):
  d[i]=b1[i]

for i in range(2,n+1):
  num=l[-i]
  count=0
  while num!=0 or count<len(b1):
    d[count]+=num%2
    num//=2
    count+=1

ans=0
table=[1]
for i in range(60):
  table.append((2*table[-1])%(10**9+7))
for i in d: 
  ans=(ans+table[i]*(n-d[i])*d[i])%(10**9+7)
print(ans)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


class Mod:
    def __init__(self, m):
        self.m = m

    def add(self, a, b):
        return (a + b) % self.m

    def sub(self, a, b):
        return (a - b) % self.m

    def mul(self, a, b):
        return ((a % self.m) * (b % self.m)) % self.m

    def div(self, a, b):
        return self.mul(a, pow(b, self.m-2, self.m))

    def pow(self, a, b):
        return pow(a, b, self.m)

@mt
def slv(N, A):
    ans = 0
    M = Mod(10**9+7)
    for i in range(0, 60):
        m = 1 << i
        c = 0
        for a in A:
            if m & a > 0:
                c += 1
        ans = M.add(M.mul(M.mul(c, N-c), m), ans)
    return ans

def main():
    N = read_int()
    A = read_int_n()
    print(slv(N, A))

    
    
    


if __name__ == '__main__':
    main()

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1

def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


class Mod:
    def __init__(self, m):
        self.m = m

    def add(self, a, b):
        return (a + b) % self.m

    def sub(self, a, b):
        return (a - b) % self.m

    def mul(self, a, b):
        return ((a % self.m) * (b % self.m)) % self.m

    def div(self, a, b):
        return self.mul(a, pow(b, self.m-2, self.m))

    def pow(self, a, b):
        return pow(a, b, self.m)

@mt
def slv(N, A):
    ans = 0
    M = Mod(10**9+7)
    for i in range(0, 60):
        m = 1 << i
        c = 0
        for a in A:
            if m & a > 0:
                c += 1
        ans = M.add(M.mul(M.mul(c, N-c), m), ans)
    return ans

def main():
    N = read_int()
    A = read_int_n()
    print(slv(N, A))

    
    
    


if __name__ == '__main__':
    main()

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

N = INT()
A = LIST()

ans = 0

for i in range(60):
    bit = 1 << i
    cnt1 = 0
    for a in A:
        
        if a & bit:
            cnt1 += 1
    cnt0 = N - cnt1
    
    cnt = cnt0 * cnt1 % MOD
    ans += cnt * bit % MOD
print(ans%MOD)

Solution (Python):
from sys import stdin, stdout
 
ii = lambda: int(stdin.readline())
mi = lambda: map(int, stdin.readline().strip().split())
li = lambda: list(mi())

MOD = int(10 ** 9 + 7)

n = ii()
A = li()

ans = 0
for j in range(60):
	cnt = [0] * 2
	for i in range(int(n)):
		c = (A[i] >> j) & 1
		ans += cnt[c ^ 1] << j
		cnt[c] += 1

ans %= MOD

stdout.write(str(ans) + "\n")

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
lists=list(map(int,input().split()))
length=61
use=[0 for i in range(61)]
a,b=divmod(n,9)
anslist=[0 for i in range(a+1)]
for  j in range(n):
    k=format(lists[j],"0%ib"%length)
    k=k[::-1]
    p,q=divmod(j,9)
    if p>a:
        anslist.append(str(k))
    else:
        anslist[p]+=int(k)
answer=0
for some in anslist:
    some=str(some)
    some=some.zfill(61)
    for j in range(61):
        if int(some[j])!=0:
            use[j]+=int(some[j])

for j in range(61):
    answer+=(2**j)*use[j]*(n-use[j])%(10**9+7)
print(answer%(10**9+7))

Solution (Python):
import sys
input=sys.stdin.readline
n=int(input())
lists=list(map(int,input().split()))
length=61
use=[0 for i in range(61)]
a,b=divmod(n,9)
anslist=[0 for i in range(a+1)]
for  j in range(n):
    k=format(lists[j],"0%ib"%length)
    k=k[::-1]
    p,q=divmod(j,9)
    if p>a:
        anslist.append(str(k))
    else:
        anslist[p]+=int(k)
answer=0
for some in anslist:
    some=str(some)
    some=some.zfill(61)
    for j in range(61):
        if int(some[j])!=0:
            use[j]+=int(some[j])

for j in range(61):
    answer+=(2**j)*use[j]*(n-use[j])%(10**9+7)
print(answer%(10**9+7))

Solution (Python):
mod = 10 ** 9 + 7
n = int(input())
a = list(map(lambda x: format(int(x), "b").zfill(60), input().split()))

ans = 0
for i in range(60):
    cnt = 0
    for j in a:
        if j[- i - 1] == "1":
            cnt += 1
    tmp = cnt * (n - cnt)
    for _ in range(i):
        tmp = tmp * 2 % mod
    ans += tmp
print(ans % mod)

Solution (Python):
n = int(input())
xs = [int(x) for x in input().split()]
M = 10**9 + 7
r = 0
for i in range(61):
    k = 0
    for x in xs:
        k += (x >> i) % 2
    r = (r + ((n-k) * k % M) * pow(2, i) )% M

print(r)

Solution (Python):
n=int(input())
lists=list(map(int,input().split()))
length=61
use=[0 for i in range(61)]
a,b=divmod(n,9)
anslist=[0 for i in range(a+1)]
for  j in range(n):
    k=format(lists[j],"0%ib"%length)
    k=k[::-1]
    p,q=divmod(j,9)
    if p>a:
        anslist.append(str(k))
    else:
        anslist[p]+=int(k)
answer=0
for some in anslist:
    some=str(some)
    some=some.zfill(61)
    for j in range(61):
        if int(some[j])!=0:
            use[j]+=int(some[j])

for j in range(61):
    answer+=(2**j)*use[j]*(n-use[j])%(10**9+7)
print(answer%(10**9+7))

Solution (Python):
import numpy as np

mod = 10 ** 9 + 7
n = int(input())
a = np.array(list(input().split()), np.int64)

ans = 0
for i in range(60):
    b = (a >> i) & 1
    cnt = np.sum(b[b > 0])
    tmp = cnt * (n - cnt)
    for _ in range(i):
        tmp = tmp * 2 % mod
    ans += tmp
print(ans % mod)

Solution (Python):
import numpy as np
 
n = int(input())
arr = np.array([int(i) for i in input().split()])
mod = 10 ** 9 + 7
s = 0

for i in range(60):
    assert np.count_nonzero(arr & 1) == np.sum(arr & 1)
    c1 = np.count_nonzero(arr & 1)
    s += 2 ** i * c1 * (n - c1)
    arr >>= 1
print(s % mod)

Solution (Python):
import numpy as np
 
n = int(input())
arr = np.array([int(i) for i in input().split()])
mod = 10 ** 9 + 7
s = 0

for i in range(60):
    c1 = np.count_nonzero(arr & 1)
    s += 2 ** i * c1 * (n - c1)
    arr >>= 1
print(s % mod)

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
ans = 0
for j in range(61):
  ones = 0
  for i in A:
    if i>>j & 1:
      ones += 1
  ans += 2**j*((n-ones)*ones)
print(ans%(10**9+7))

Solution (Python):
import sys
import numpy as np
 
n = int(input())
lst = [int(i) for i in sys.stdin.readline().split()]
arr = np.array(lst, np.int64)
mod = 10 ** 9 + 7
s = 0

for i in range(60):
    c1 = np.count_nonzero(arr & 1)
    s += 2 ** i * c1 * (n - c1)
    arr >>= 1
print(s % mod)

Solution (Python):
MOD = 10**9 + 7
n = int(input())
a = list(map(int, input().split()))

n_bit = max(a).bit_length()
b = [(1 << j) % MOD for j in range(n_bit)]

ans = 0
bit = [0] * n_bit
for i in range(n):
    for j in range(n_bit):
        if (a[i] >> j) & 1:
            ans += b[j] * (i - bit[j])
            bit[j] += 1
        else:
            ans += b[j] * bit[j]
        ans %= MOD

print(ans)

Solution (Python):
import sys
import numpy as np
 
n = int(input())
lst = [int(i) for i in sys.stdin.readline().split()]
arr = np.array(lst, np.int64)
mod = 10 ** 9 + 7
c = []

while arr.any():
    c1 = np.count_nonzero(arr & 1)
    c.append(c1 * (n - c1))
    arr >>= 1
print(sum([(v * 2 ** i) for i, v in enumerate(c)]) % mod)

Solution (Python):
import sys
import numpy as np
 
n = int(input())
lst = [int(i) for i in sys.stdin.readline().split()]
arr = np.array(lst, np.int64)

mod = 10 ** 9 + 7
x_sum = 0

for i in range(60):
    c1 = np.count_nonzero(arr & 1)
    x_sum += (c1 * (n - c1) * 2 ** i)
    x_sum %= mod
    arr >>= 1
print(x_sum)

Solution (Python):
N = int(input())

A = map(int, input().split())

ones = [0] * 60
m = 10 ** 9 + 7

for Ai in A:
    for digit in range(60):
        ones[digit] += ((Ai >> digit) & 1)

res = 0
for i, num in enumerate(ones):
    res += (1 << i) * num * (N - num)

print(res % m)