"""# 

### 谜题描述
Only a few know that Pan and Apollo weren't only battling for the title of the GOAT musician. A few millenniums later, they also challenged each other in math (or rather in fast calculations). The task they got to solve is the following:

Let x_1, x_2, …, x_n be the sequence of n non-negative integers. Find this value: $$$∑_{i=1}^n ∑_{j=1}^n ∑_{k=1}^n (x_i   \&   x_j) ⋅ (x_j   |   x_k)$$$

Here \& denotes the [bitwise and,](https://en.wikipedia.org/wiki/Bitwise_operation#AND) and | denotes the [bitwise or.](https://en.wikipedia.org/wiki/Bitwise_operation#OR)

Pan and Apollo could solve this in a few seconds. Can you do it too? For convenience, find the answer modulo 10^9 + 7.

Input

The first line of the input contains a single integer t (1 ≤ t ≤ 1 000) denoting the number of test cases, then t test cases follow.

The first line of each test case consists of a single integer n (1 ≤ n ≤ 5 ⋅ 10^5), the length of the sequence. The second one contains n non-negative integers x_1, x_2, …, x_n (0 ≤ x_i < 2^{60}), elements of the sequence.

The sum of n over all test cases will not exceed 5 ⋅ 10^5.

Output

Print t lines. The i-th line should contain the answer to the i-th text case.

Example

Input


8
2
1 7
3
1 2 4
4
5 5 5 5
5
6 2 2 1 0
1
0
1
1
6
1 12 123 1234 12345 123456
5
536870912 536870911 1152921504606846975 1152921504606846974 1152921504606846973


Output


128
91
1600
505
0
1
502811676
264880351

Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
```python
import sys
testing = len(sys.argv) == 4 and sys.argv[3] == \"myTest\"
if testing:
    cmd = sys.stdout
    from time import time
    start_time = int(round(time() * 1000)) 
    input = open(sys.argv[1], 'r').readline
    sys.stdout = open(sys.argv[2], 'w')
else:
    input = sys.stdin.readline
mod = 10**9+7
# from math import ceil
# from collections import defaultdict as dd
# from heapq import *
############ ---- I/O Functions ---- ############
def intin():
    return(int(input()))
def intlin():
    return(list(map(int,input().split())))
def chrin():
    s = input()
    return(list(s[:len(s) - 1]))
def strin():
    s = input()
    return s[:len(s) - 1]
def intlout(l, sep=\" \"):
    print(sep.join(map(str, l)))

def main():
    n = intin()
    a = intlin()
    b = [format(x,'b')[::-1] for x in a]
    lens = [len(x) for x in b]
    maxK = max(lens)
    bcnt = [0]*maxK
    for i in xrange(n):
        x = b[i]
        for k in xrange(lens[i]):
            if x[k]=='1':
                bcnt[k] += 1
    kpowb = [(((1<<k)%mod)*bcnt[k])%mod for k in xrange(maxK)]
    summ = sum(kpowb)%mod   # sum(a)
    ans = 0
    for j in xrange(n):
        x = b[j]
        tmp = 0
        for k in xrange(lens[j]):
            if x[k] == '1':
                tmp += kpowb[k]
        tmp %= mod
        ans = (ans + (tmp*(((a[j]%mod)*n)%mod + summ - tmp)%mod)%mod)%mod
    # print(ans)
    return(ans)

if __name__ == \"__main__\":
    ans = []
    for _ in xrange(intin()):
        ans.append(main())
        # main()
        # print(\"YES\" if main() else \"NO\")
    intlout(ans,'\n')
    # main()

    if testing:
        sys.stdout = cmd
        print(int(round(time() * 1000))  - start_time)
```


请完成上述谜题的训练场环境类实现，包括所有必要的方法。
"""

from bootcamp import Basebootcamp
import re
import random
from bootcamp import Basebootcamp

MOD = 10**9 + 7

def compute_answer(n, array):
    if n == 0:
        return 0
    a = array
    b = [format(x, 'b')[::-1] for x in a]
    lens = [len(x) for x in b]
    maxK = max(lens) if lens else 0
    bcnt = [0] * maxK
    for i in range(n):
        x = b[i]
        for k in range(len(x)):
            if x[k] == '1':
                if k >= len(bcnt):
                    bcnt += [0] * (k - len(bcnt) + 1)
                bcnt[k] += 1
    kpowb = [ ((1 << k) % MOD) * bcnt[k] % MOD for k in range(len(bcnt)) ]
    summ = sum(kpowb) % MOD
    ans = 0
    for j in range(n):
        xj = a[j] % MOD
        x_bits = b[j]
        tmp = 0
        for k in range(len(x_bits)):
            if x_bits[k] == '1' and k < len(kpowb):
                tmp = (tmp + kpowb[k]) % MOD
        term_part = ( (xj * n) % MOD + (summ - tmp) % MOD ) % MOD
        term = (tmp * term_part) % MOD
        ans = (ans + term) % MOD
    return ans

class Eapolloversuspanbootcamp(Basebootcamp):
    def __init__(self, min_n=1, max_n=1000, max_x=10**18):
        self.min_n = max(1, min_n)
        self.max_n = min(max_n, 5*10**5)
        self.max_x = min(max_x, (1 << 60)-1)  # 确保不超过题目限制
    
    def case_generator(self):
        # 增加更多边界情况
        case_type = random.choice([0, 1, 2, 3])
        n = random.randint(self.min_n, self.max_n)
        
        if case_type == 0:  # 全零
            array = [0]*n
        elif case_type == 1:  # 全相同高位
            base = random.getrandbits(60)
            array = [base]*n
        elif case_type == 2:  # 混合高低位
            array = [random.getrandbits(random.randint(0, 60)) for _ in range(n)]
        else:  # 极大值
            array = [(1 << 60)-1 for _ in range(n)]
        
        return {"n": n, "array": array}
    
    @staticmethod
    def prompt_func(question_case):
        n = question_case['n']
        array = question_case['array']
        case_input = f"1\n{n}\n{' '.join(map(str, array))}"
        problem_desc = (
            "数学挑战：计算三重位运算和\n\n"
            "给定长度为n的非负整数序列，计算：\n"
            "S = ΣΣΣ (x_i & x_j) * (x_j | x_k) mod 1e9+7 (i,j,k从1到n)\n\n"
            "输入格式：\n"
            "第一行t(测试用例数)\n"
            "每个用例两行：n和数组\n\n"
            "当前测试用例输入：\n"
            f"{case_input}\n\n"
            "将答案放在[answer]标签内，例如：[answer] 123 [/answer]"
        )
        return problem_desc
    
    @staticmethod
    def extract_output(output):
        # 更健壮的正则表达式
        matches = re.findall(
            r'\[answer\][\s\n]*(-?\d+)[\s\n]*\[/answer\]', 
            output, 
            re.IGNORECASE | re.DOTALL
        )
        return int(matches[-1]) if matches else None
    
    @classmethod
    def _verify_correction(cls, solution, identity):
        try:
            expected = compute_answer(identity['n'], identity['array'])
            user_ans = int(solution) % MOD
            return user_ans == expected % MOD
        except:
            return False