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.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class d1572 implements Runnable{
	
    public static void main(String[] args) {
    	try{
            new Thread(null, new d1572(), "process", 1<<26).start();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
	public void run() {
		FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
//		try {
//            out = new PrintWriter("file.out");
//        } catch (FileNotFoundException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
		Task solver = new Task();
		int t = scan.nextInt();
		//int t = 1;
		for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
		out.close();
	}

	static class Task {
		static final int oo = Integer.MAX_VALUE;
		static final long OO = Long.MAX_VALUE;

		public void solve(int testNumber, FastReader sc, PrintWriter out) {
		    int N = sc.nextInt();
		    int[] arr = sc.readArray(N);
		    
		    int total = 0;
		    for(int i = 0; i < N; i++) {
			if(arr[i] == 1)
			    total++;
		    }
		    
		    if(total % 2 == 1) {
			out.println("NO");
			return;
		    }
		    
		    List<Integer> ops = new ArrayList<>();
		    int count = 0;
		    int zeroCount = 0;
		    int i;
		    for(i = 0; i < N; i++) {
			if(arr[i] == 1) {
			    count++;
			    zeroCount = 0;
			} else {
			    zeroCount++;
			    if(count % 2 == 0) {
				break;
			    } else {
				if(i == N-1 || arr[i+1] == 0)
				    continue;
				
				if(zeroCount % 2 == 0)
				    continue;
				
				int j;
				for(j = i-1;; j-= 2) {
				    ops.add(j);
				    if(arr[j] == 1) {
					break;
				    }
				}
				
				arr[j] = 0;
				
				for(j = j + 2; j < i; j+= 2) {
				    ops.add(j);
				}
				
				arr[j] = 0;
				break;
			    }
			}
			
		    }
		    
//		    dbg(i);
//		    dbg(ops);
//		    dbg(arr);
		    
		    if(i == N) {
			out.println("NO");
			return;
		    }
		    
		    for(int j = i; j < N - 2; j++) {
			if(arr[j] == 0){
			    if(arr[j+1] == 1 && arr[j+2] == 1) {
				ops.add(j);
				arr[j+1] = 0;
				arr[j+2] = 0;
			    }
			} else {
			    if(arr[j+1] == 0 && arr[j+2] == 1) {
				ops.add(j);
				arr[j] = 0;
				arr[j+2] = 0;
			    } else if (arr[j+1] == 0 && arr[j+2] == 0) {
				ops.add(j);
				ops.add(j-1);
				arr[j] = 0;
				arr[j+2] = 1;
			    }
			}
				
		    }
		    
		    for(int j = i; j >= 2; j--) {
			if(arr[j] == 0){
			    if(arr[j-1] == 1 && arr[j-2] == 1) {
				ops.add(j-2);
				arr[j-1] = 0;
				arr[j-2] = 0;
			    }
			} else {
			    if(arr[j-1] == 0 && arr[j-2] == 1) {
				ops.add(j-2);
				arr[j] = 0;
				arr[j-2] = 0;
			    } else if (arr[j-1] == 0 && arr[j-2] == 0) {
				ops.add(j-2);
				ops.add(j-1);
				arr[j] = 0;
				arr[j-2] = 1;
			    }
			}
		
		    }
		    
		    out.println("YES");
		    out.println(ops.size());
		    for(int each: ops) {
			out.print(each+1+ " ");
		    }
		    
		    if(ops.size() > 0)
			out.println();
		}
	}
	
	static long modDivide(long a, long b, long MOD) {
		a %= MOD;
		return (binpow(b, MOD-2, MOD) * a) % MOD;
	}
	static long binpow(long a, long b, long m) {
		a %= m;
		long res = 1;
		while (b > 0) {
			if ((b & 1) == 1)
				res = res * a % m;
			a = a * a % m;
			b >>= 1;
		}
		return res;
	}
	static int[] reverse(int a[]) 
    { 
        int[] b = new int[a.length]; 
        for (int i = 0, j = a.length; i < a.length; i++, j--) { 
            b[j - 1] = a[i]; 
        } 
        
        return b;
    }
	static long[] reverse(long a[]) 
    { 
        long[] b = new long[a.length]; 
        for (int i = 0, j = a.length; i < a.length; i++, j--) { 
            b[j - 1] = a[i]; 
        } 
        
        return b;
    }
	static void sort(int[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static void sort(long[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static class tup implements Comparable<tup>, Comparator<tup>{
		int a, b;
		tup(int a,int b){
			this.a=a;
			this.b=b;
		}
		public tup() {
		}
		@Override
		public int compareTo(tup o){
			return Integer.compare(b,o.b);
		}
		@Override
		public int compare(tup o1, tup o2) {
			return Integer.compare(o1.b, o2.b);
		}
		
		@Override
	    public int hashCode() {
			return Objects.hash(a, b);
	    }
 
	    @Override
	    public boolean equals(Object obj) {
	    	if (this == obj)
                return true;
	    	if (obj == null)
                return false;
	    	if (getClass() != obj.getClass())
                return false;
	    	tup other = (tup) obj;
	    	return a==other.a && b==other.b;
	    }
	    
	    @Override
	    public String toString() {
	    	return a + " " + b;
	    }
	}
	
	static void shuffle(int[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			int temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static void shuffle(long[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			long temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
		
		int[] readArray(int size) {
			int[] a = new int[size];
			for(int i = 0; i < size; i++) {
				a[i] = nextInt();
			}
			return a;
		}
		
		long[] readLongArray(int size) {
			long[] a = new long[size];
			for(int i = 0; i < size; i++) {
				a[i] = nextLong();
			}
			return a;
		}
	}
	
	static void dbg(int[] arr) {
		System.out.println(Arrays.toString(arr));
	}
	static void dbg(long[] arr) {
		System.out.println(Arrays.toString(arr));
	}
	static void dbg(boolean[] arr) {
		System.out.println(Arrays.toString(arr));
	}

	static void dbg(Object... args) {
        for (Object arg : args)
            System.out.print(arg + " ");
        System.out.println();
    }
}