Little Elephant from the Zoo of Lviv likes cards. He has N cards, each of which has one of 1000 colors. The colors are numbered from 1 to 1000.
Little Elephant and Big Hippo are playing the following game. At first Little Elephant takes some subset of cards, and Big Hippo takes the rest of them. Here, Little Elephant can choose to take all of the cards, or none of the cards.
Then they play 1000 rounds: in round k (k = 1, 2, ..., 1000), they count the number of cards each has of the color k. Let Little Elephant has a cards of the color k, and Big Hippo has b cards of the color k. Then if a > b Little Elephant scores |a-b| points, otherwise Big Hippo scores |a-b| points in this round, where |x| denotes the absolute value of x.
You are given the number of cards N and the array C - list of colors of all N cards. Find the number of subsets (among all 2^N subsets) for which Little Elephant wins the game: that is, he gains more points than Big Hippo in total, if Little Elephant takes the subset at first. Since the answer can be large, print it modulo 1000000007 (10^9+7).


Input
First line of the input contains single integer T - the number of test cases. Then T test cases follow.
First line of each test case contains single integer N. Second line contains N integers separated by space - the array C.


Output
For each test case, print the answer in one line.


Constraints

1 ≤ T ≤ 1001 ≤ N ≤ 10001 ≤ Ci ≤ 1000, where Ci denotes the i-th element of the array C

Example

Input:
2
3
1 2 3
4
1 1 3 2

Output:
4
5
'''
Created on Feb 22, 2013

@author: anuvrat
'''

import sys

MODULATOR = 1000000007

class Memoize( object ):
    def __init__( self, f ):
        self.f, self.cache = f, {}

    def __call__( self, *args ):
        if not args in self.cache: self.cache[args] = self.f( *args )
        return self.cache[args]

@Memoize
def nCk( n, k ): return reduce( lambda acc, m:acc * ( n - k + m ) / m, range( 1, k + 1 ), 1 )

@Memoize
def winning_options( n ):
    if n % 2: return pow( 2, n - 1, MODULATOR )
    else:
        return ( pow( 2, n - 1 ) - nCk( n, n / 2 ) / 2 ) % MODULATOR

def main():
    for _ in  xrange( int( sys.stdin.readline() ) ):
        n = int( sys.stdin.readline() )
        colors = map( int, sys.stdin.readline().strip().split() )
        print winning_options( n )

main()