#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;
}

### Prompt

In cpp, your task is to solve the following problem:

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].

### Response

```cpp
#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;
}

```