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: #######################################################################################################
  #######        ###########         #######    #########    #######           ######               #####
  ######  ######  #########  ######  #######  ###########  #############   ################  ############
  ######  #######  ########  #######  ######  ###########  ##############  ################  ############
  ######  ######  #########  #######  ######               #############   ################  ############
  ######  ###   ###########  #######  ######  ###########  #############   ################  ############
  ######  #####  ##########  #######  ######  ###########  #############   ################  ############
  ######  ######  ##########  #####  #######  ###########  #############   ################  ############
  ####     ######     ######        ######    ########      #######            ##########     ###########
  #######################################################################################################
  import os
  import sys
  from io import BytesIO, IOBase
  #-----------------------IMPORTANT  FUNCTIONS ---------------------------------#
  from math import cos, pi, ceil, pi, tan, floor, gcd, sqrt, log2, factorial, log10
  from collections import Counter
  from copy import deepcopy
  from string import ascii_lowercase, ascii_uppercase
  from statistics import mean, median, mode
  from bisect import *
  
  alpha = ascii_lowercase
  beta = ascii_uppercase
  
  
  #-----------------------NEXT POWER OF 2---------------------------------------#
  def nextPowerOf2(n):
      p = 1
      if (n and not (n & (n - 1))):
          return n
      while (p < n):
          p <<= 1
      return p
  #-----------------------COMPOSITE  CHECK---------------------------------------#
  def isComposite(n):
      if (n <= 1):
          return False
      if (n <= 3):
          return False
      if (n % 2 == 0 or n % 3 == 0):
          return True
      i = 5
      while(i * i <= n):
          if (n % i == 0 or n % (i + 2) == 0):
              return True
          i = i + 6
      return False
  
  
  #-----------------------GET DIVISORS 1 TO <=N   ------------------------------#
  def get_Divisors(n):
      arr = []
      i = 1
      while i <= sqrt(n):
          if (n % i == 0):
              if (n / i == i):
                  arr.append(i)
              else:
                  arr.append(i)
                  arr.append(n // i)
          i = i + 1
  
      return arr
  
  
  #----------------------CHECK    PRIMES-----------------------------------#
  def isprime(n):
      if n == 1:
          return 0
      i = 2
      while (i * i <= n):
          if (n % i == 0):
              return 0
          i += 1
      return 1
  
  
  #-----------------------PRE COMPUTED  PRIMES-----------------------------------#
  def Sieve(n):
      prime = [True for i in range(n + 1)]
      prime[0] = False
      prime[1] = False
      p = 2
      while (p * p <= n):
          if (prime[p] == True):
              for i in range(p * p, n + 1, p):
                  prime[i] = False
          p += 1
      return prime
  
  
  #-----------------------LARGER VALUE OF  X,Y,10**9+7 --------------------------#
  def power(x, y, p):
      res = 1
      x = x % p
      if (x == 0):
          return 0
      while (y > 0):
          if ((y & 1) == 1):
              res = (res * x) % p
          y = y >> 1
          x = (x * x) % p
      return res
  
  
  #-----------------------       CREATE MATRIX         --------------------------#
  def create_matrix(n, m):
      mat = [[] for i in range(n)]
      for i in range(n):
          for j in range(m):
              mat[i].append(0)
      return mat
  
  
  #By Default Counter stores the value in decending orderCounter({4: 2, 8: 2, 2: 1, 9: 1}
  #s=sorted(s.items(),key=lambda k:(k[0],k[1])) ---> [(2, 1), (4, 2), (8, 2), (9, 1)]
  #sort 2nd value  from bada se chhota  then(4,2)(8,2)->>(8,2)(4,2) s=sorted(s.items(),key=lambda k:(-k[1],-k[0]))  [(8, 2), (4, 2), (9, 1), (2, 1)]
  #for list pair in a list    s.sort(key=lambda k:(-k[1],-k[0])) [[3, 4], [8, 2], [4, 2]]
  # from functools import cmp_to_key
  #how to use compare ----ss = sorted(s, key=cmp_to_key(compare))
  #-----------------------*****CODE STARTS  HERE*****--------------------------#
  
  # from queue import Queue
  # from random import *
  def main():
      for ttt in range(int(input())):
          n=int(input())
          arr=list(map(int,input().split()))
          ans=0 
          cc=0
          for i in range(n):
              if arr[i]==1:
                  ans+=1
              if arr[i]==0:
                  cc+=1 
          print(ans*(2**cc))
  # Region Fast_______io
  BUFSIZE = 8192
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  if __name__ == "__main__":
      main()