description: Luntik came out for a morning stroll and found an array a of length n. He calculated the sum s of the elements of the array (s= ∑_{i=1}^{n} a_i). Luntik calls a subsequence of the array a nearly full if the sum of the numbers in that subsequence is equal to s-1.
  
  Luntik really wants to know the number of nearly full subsequences of the array a. But he needs to come home so he asks you to solve that problem!
  
  A sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. The next 2 ⋅ t lines contain descriptions of test cases. The description of each test case consists of two lines.
  
  The first line of each test case contains a single integer n (1 ≤ n ≤ 60) — the length of the array.
  
  The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the elements of the array a.
  
  Output
  
  For each test case print the number of nearly full subsequences of the array.
  
  Example
  
  Input
  
  
  5
  5
  1 2 3 4 5
  2
  1000 1000
  2
  1 0
  5
  3 0 2 1 1
  5
  2 1 0 3 0
  
  
  Output
  
  
  1
  0
  2
  4
  4
  
  Note
  
  In the first test case, s=1+2+3+4+5=15, only (2,3,4,5) is a nearly full subsequence among all subsequences, the sum in it is equal to 2+3+4+5=14=15-1.
  
  In the second test case, there are no nearly full subsequences.
  
  In the third test case, s=1+0=1, the nearly full subsequences are (0) and () (the sum of an empty subsequence is 0).
solution: # cook your dish here
  from collections import deque, defaultdict
  from math import sqrt, ceil, factorial, floor, inf, log2, sqrt, gcd
  import bisect
  import copy
  from itertools import combinations
  import sys
  import heapq
  def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
  def get_ints(): return map(int, sys.stdin.readline().strip().split())
  def input(): return sys.stdin.readline().strip()
  
  
  def binomialCoef(n, k):
      C = [[0 for x in range(k + 1)] for x in range(n + 1)]
  
      for i in range(n + 1):
          for j in range(min(i, k) + 1):
              # Base Cases
              if j == 0 or j == i:
                  C[i][j] = 1
  
              else:
                  C[i][j] = C[i - 1][j - 1] + C[i - 1][j]
  
      return C[n][k]
  
  for _ in range(int(input())):
  
     ## a,b,c=get_ints()
      # fa,fb,fc=False,False,False
      # if a%2==1:
      #     fa=True
      #
      # if b%2==1:
      #     fb=True
      #
      # if c%2==1:
      #     fc=True
      #
      # if (fa==False and fb==False and fc==False) or(fa==True and fb==True and fc==True):
      #     print(0)
      #     continue
      # if (fb==True and fa==False and fc==False) or (fa==True and fc==True and fb==False):
      #     print(2)
      #     continue
      #
      # if (fc==True and fa==False and fb==False):
      #     print(3)
      #     continue
      #
      # print(1)
  
      n=int(input())
      a=get_array()
      ones=a.count(1)
      zeros=a.count(0)
  
      tot=0
  
      for i in range(zeros+1):
          tot+=binomialCoef(zeros,i)
  
      tot=int(tot)
  
      print(tot*ones)
  
  
  
  