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 java.io.*;
  import java.util.*;
   public class Solution {
  	public static void main(String[] args) throws Exception {
  		FastIO io = new FastIO();
  		int test=io.nextInt();
  		while(test>0)
  		{
  		    int n=io.nextInt();
  		    long arr[]=new long[n];
  		    for(int i=0;i<n;i++)arr[i]=io.nextLong();
  		    int o=0,z=0;
  		    for(long x:arr)
  		    {
  		        if(x==0L)z++;
  		        else if(x==1L)o++;
  		    }
  		    long ans=((long)Math.pow(2,z))*o;
  		    io.println(ans);
  		    test--;
  		}
  		io.close();
  	}
  }
  
   class FastIO extends PrintWriter {
  	private InputStream stream;
  	private byte[] buf = new byte[1<<16];
  	private int curChar, numChars;
   
  	// standard input
  	public FastIO() { this(System.in,System.out); }
  	public FastIO(InputStream i, OutputStream o) {
  		super(o);
  		stream = i;
  	}
  	// file input
  	public FastIO(String i, String o) throws IOException {
  		super(new FileWriter(o));
  		stream = new FileInputStream(i);
  	}
   
  	// throws InputMismatchException() if previously detected end of file
  	private int nextByte() {
  		if (numChars == -1) throw new InputMismatchException();
  		if (curChar >= numChars) {
  			curChar = 0;
  			try {
  				numChars = stream.read(buf);
  			} catch (IOException e) {
  				throw new InputMismatchException();
  			}
  			if (numChars == -1) return -1; // end of file
  		}
  		return buf[curChar++];
  	}
   
  	public String nextLine() {
  		int c; do { c = nextByte(); } while (c <= '\n');
  		StringBuilder res = new StringBuilder();
  		do { res.appendCodePoint(c); c = nextByte(); } while (c > '\n');
  		return res.toString();
  	}
   
  	public String next() {
  		int c; do { c = nextByte(); } while (c <= ' ');
  		StringBuilder res = new StringBuilder();
  		do { res.appendCodePoint(c); c = nextByte(); } while (c > ' ');
  		return res.toString();
  	}
   
  	public int nextInt() { 
  		int c; do { c = nextByte(); } while (c <= ' ');
  		int sgn = 1; if (c == '-') { sgn = -1; c = nextByte(); }
  		int res = 0;
  		do {
  			if (c < '0' || c > '9')
  				throw new InputMismatchException();
  			res = 10*res+c-'0';
  			c = nextByte();
  		} while (c > ' ');
  		return res * sgn;
  	}
   
    public long nextLong() { 
  		int c; do { c = nextByte(); } while (c <= ' ');
  		long sgn = 1; if (c == '-') { sgn = -1; c = nextByte(); }
  		long res = 0;
  		do {
  			if (c < '0' || c > '9')
  				throw new InputMismatchException();
  			res = 10*res+c-'0';
  			c = nextByte();
  		} while (c > ' ');
  		return res * sgn;
  	}
   
  	public double nextDouble() { return Double.parseDouble(next()); }
  }
  