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: #include <bits/stdc++.h>
  #pragma GCC optimize("Ofast")
  #pragma GCC optimize("unroll-loops")
  #pragma GCC optimize("inline")
  using namespace std;
  template <class T>
  struct cLtraits_identity {
    using type = T;
  };
  template <class T>
  using cLtraits_try_make_signed =
      typename conditional<is_integral<T>::value, make_signed<T>,
                           cLtraits_identity<T> >::type;
  template <class S, class T>
  struct cLtraits_common_type {
    using tS = typename cLtraits_try_make_signed<S>::type;
    using tT = typename cLtraits_try_make_signed<T>::type;
    using type = typename common_type<tS, tT>::type;
  };
  template <class S, class T>
  inline auto max_L(S a, T b) -> typename cLtraits_common_type<S, T>::type {
    return (typename cLtraits_common_type<S, T>::type)a >=
                   (typename cLtraits_common_type<S, T>::type)b
               ? a
               : b;
  }
  inline int my_getchar() {
    static char buf[1048576];
    static int s = 1048576;
    static int e = 1048576;
    if (s == e && e == 1048576) {
      e = fread(buf, 1, 1048576, stdin);
      s = 0;
    }
    if (s == e) {
      return EOF;
    }
    return buf[s++];
  }
  inline void rd(int &x) {
    int k;
    int m = 0;
    x = 0;
    for (;;) {
      k = my_getchar();
      if (k == '-') {
        m = 1;
        break;
      }
      if ('0' <= k && k <= '9') {
        x = k - '0';
        break;
      }
    }
    for (;;) {
      k = my_getchar();
      if (k < '0' || k > '9') {
        break;
      }
      x = x * 10 + k - '0';
    }
    if (m) {
      x = -x;
    }
  }
  inline int rd_int(void) {
    int x;
    rd(x);
    return x;
  }
  struct MY_WRITER {
    char buf[1048576];
    int s;
    int e;
    MY_WRITER() {
      s = 0;
      e = 1048576;
    }
    ~MY_WRITER() {
      if (s) {
        fwrite(buf, 1, s, stdout);
      }
    }
  };
  MY_WRITER MY_WRITER_VAR;
  void my_putchar(int a) {
    if (MY_WRITER_VAR.s == MY_WRITER_VAR.e) {
      fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
      MY_WRITER_VAR.s = 0;
    }
    MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
  }
  inline void wt_L(char a) { my_putchar(a); }
  inline void wt_L(int x) {
    int s = 0;
    int m = 0;
    char f[10];
    if (x < 0) {
      m = 1;
      x = -x;
    }
    while (x) {
      f[s++] = x % 10;
      x /= 10;
    }
    if (!s) {
      f[s++] = 0;
    }
    if (m) {
      my_putchar('-');
    }
    while (s--) {
      my_putchar(f[s] + '0');
    }
  }
  inline void wt_L(const char c[]) {
    int i = 0;
    for (i = 0; c[i] != '\0'; i++) {
      my_putchar(c[i]);
    }
  }
  int N;
  int A[200000];
  int res[200000];
  int ress;
  void doit(int i) {
    res[ress++] = i;
    auto Lj4PdHRW = (A[i] ^ A[i + 1] ^ A[i + 2]);
    A[i] = Lj4PdHRW;
    A[i + 1] = Lj4PdHRW;
    A[i + 2] = Lj4PdHRW;
  }
  int main() {
    int KL2GvlyY;
    int Q5VJL1cS = rd_int();
    for (KL2GvlyY = (0); KL2GvlyY < (Q5VJL1cS); KL2GvlyY++) {
      int x;
      int y;
      rd(N);
      {
        int RZTsC2BF;
        for (RZTsC2BF = (0); RZTsC2BF < (N); RZTsC2BF++) {
          rd(A[RZTsC2BF]);
        }
      }
      int WYIGIcGE;
      int t_ynMSdg;
      if (N == 0) {
        t_ynMSdg = 0;
      } else {
        t_ynMSdg = A[0];
        for (WYIGIcGE = (1); WYIGIcGE < (N); WYIGIcGE++) {
          t_ynMSdg += A[WYIGIcGE];
        }
      }
      if (t_ynMSdg % 2) {
        wt_L("NO");
        wt_L('\n');
        continue;
      }
      ress = 0;
      for (x = (0); x < (N); x++) {
        if (A[x] == 1) {
          break;
        }
      }
      for (y = (x); y < (N); y++) {
        if (A[y] == 0) {
          break;
        }
      }
      for (;;) {
        if (x >= N) {
          break;
        }
        if (x == 0 && y == N) {
          wt_L("NO");
          wt_L('\n');
          goto e98WHCEY;
        }
        if (x >= y) {
          for (x = (x); x < (N); x++) {
            if (A[x] == 1) {
              break;
            }
          }
          for (y = (x); y < (N); y++) {
            if (A[y] == 0) {
              break;
            }
          }
          continue;
        }
        if ((y - x) % 2 == 0) {
          if (x) {
            doit(x - 1);
            x += 2;
          } else {
            doit(y - 2);
            y -= 2;
          }
        } else {
          doit(y - 1);
          for (y = (max_L(x, y - 2)); y < (N); y++) {
            if (A[y] == 0) {
              break;
            }
          }
        }
      }
      wt_L("YES");
      wt_L('\n');
      wt_L(ress);
      wt_L('\n');
      {
        int BUotOFBp;
        if (ress == 0) {
          wt_L('\n');
        } else {
          for (BUotOFBp = (0); BUotOFBp < (ress - 1); BUotOFBp++) {
            wt_L(res[BUotOFBp] + 1);
            wt_L(' ');
          }
          wt_L(res[BUotOFBp] + 1);
          wt_L('\n');
        }
      }
    e98WHCEY:;
    }
    return 0;
  }
  