description: 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].
solution: 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);
  			}
  		}
  	}
  
  }
  