You are given a sequence a of length n consisting of 0s and 1s.

You can perform the following operation on this sequence: 

  * Pick an index i from 1 to n-2 (inclusive). 
  * Change all of a_{i}, a_{i+1}, a_{i+2} to a_{i} ⊕ a_{i+1} ⊕ a_{i+2} simultaneously, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)

Find a sequence of at most n operations that changes all elements of a to 0s or report that it's impossible.

We can prove that if there exists a sequence of operations of any length that changes all elements of a to 0s, then there is also such a sequence of length not greater than n.

Input

Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).

The first line of each test case contains a single integer n (3 ≤ n ≤ 2⋅10^5) — the length of a.

The second line of each test case contains n integers a_1, a_2, …, a_n (a_i = 0 or a_i = 1) — elements of a.

It is guaranteed that the sum of n over all test cases does not exceed 2⋅10^5.

Output

For each test case, do the following: 

  * if there is no way of making all the elements of a equal to 0 after performing the above operation some number of times, print "NO". 
  * otherwise, in the first line print "YES", in the second line print k (0 ≤ k ≤ n) — the number of operations that you want to perform on a, and in the third line print a sequence b_1, b_2, ..., b_k (1 ≤ b_i ≤ n - 2) — the indices on which the operation should be applied. 



If there are multiple solutions, you may print any.

Example

Input


3
3
0 0 0
5
1 1 1 1 0
4
1 0 0 1


Output


YES
0
YES
2
3 1
NO

Note

In the first example, the sequence contains only 0s so we don't need to change anything.

In the second example, we can transform [1, 1, 1, 1, 0] to [1, 1, 0, 0, 0] and then to [0, 0, 0, 0, 0] by performing the operation on the third element of a and then on the first element of a.

In the third example, no matter whether we first perform the operation on the first or on the second element of a we will get [1, 1, 1, 1], which cannot be transformed to [0, 0, 0, 0].
import java.util.*;
import java.io.*;
public class B {

	public static void main(String[] args) {
		FastScanner sc = new FastScanner();
		int T = sc.nextInt();
		StringBuilder sbres = new StringBuilder();
		while(T-->0) {
			int n = sc.nextInt();
			int[] arr = new int[n];
			int c = 0;
			for(int i = 0; i < n; i++) {
				arr[i] = sc.nextInt();
				c += arr[i];
			}
			if(c % 2 == 1) {
				sbres.append("NO\n"); continue;
			}
			StringBuilder sb = new StringBuilder();
			int res = 0;
			int ind = 0;
			while(ind < n && arr[ind] == 1) {
				ind++;
			}
			if(ind == n) {
				sbres.append("NO\n"); continue;
			}
			if(ind % 2 == 1) {
				ind--;
				while(ind < n-2 && count(arr, ind) != 2) {
					sb.append((ind+1)+" "); res++;
					arr[ind+1] = 1; arr[ind+2] = 1;
					ind += 2;
				}
				if(ind >= n-2) {
					sbres.append("NO\n"); continue;
				}
				else {
					while(ind > 0) {
						sb.append((ind+1)+" "); res++;
						arr[ind] = 0; arr[ind+1] = 0; arr[ind+2] = 0;
						ind -= 2;
					}
				}
			}
			else {
				ind -= 2;
				while(ind > 0) {
					sb.append((ind+1)+" "); res++;
					arr[ind] = 0; arr[ind+1] = 0; arr[ind+2] = 0;
					ind -= 2;
				}
				
			}
			for(int i = 0; i < n-2; i++) {
				int ca = count(arr, i);
				if(ca == 2) {
					sb.append((i+1)+" "); res++;
					arr[i] = 0; arr[i+1] = 0; arr[i+2] = 0;
				}
				else {
					if(ca == 1) {
						if(arr[i] == 0);
						else {
							sb.append((i+1)+" "); res++;
							arr[i] = 1; arr[i+1] = 1; arr[i+2] = 1;
							sb.append(i+" "); res++;
							arr[i-1] = 0; arr[i] = 0; arr[i+1] = 0;
						}
					}
				}
			}
			if(res == 0) {
				sbres.append("YES\n0\n");
			}
			else {
				sbres.append("YES\n"+res+"\n");
				sb.replace(sb.length()-1, sb.length(), "\n");
				sbres.append(sb);
			}
		}
		PrintWriter pw = new PrintWriter(System.out);
		pw.println(sbres.toString().trim());
		pw.flush();
	}
	static int count(int[] arr, int pos) {
		return arr[pos] + arr[pos+1] + arr[pos+2];
	}

	static class FastScanner {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		public FastScanner() {
			reader = new BufferedReader(new InputStreamReader(System.in), 32768);
			tokenizer = null;
		}
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
		public int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		public String nextLine() {
			try {
				return reader.readLine();
			} catch(IOException e) {
				throw new RuntimeException(e);
			}
		}
	}

}
