#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
  static char _c;
  static bool _f;
  x = 0;
  _f = 0;
  _c = getchar();
  while (_c < '0' || '9' < _c) {
    if (_c == '-') _f = true;
    _c = getchar();
  }
  while ('0' <= _c && _c <= '9') {
    x = (x << 1) + (x << 3) + (_c & 15);
    _c = getchar();
  }
  if (_f) x = -x;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
  read(x);
  read(args...);
}
template <typename T>
inline void Min(T &x, T y) {
  if (y < x) x = y;
}
template <typename T>
inline void Max(T &x, T y) {
  if (x < y) x = y;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double pi = (double)acos(-1.0);
const double eps = (double)1e-8;
const int e5 = (int)1e5 + 5;
const int MOD = (int)1000000007;
template <typename T0, typename T1>
inline void depair(T0 &x, T1 &y, pair<T0, T1> &p) {
  x = p.first, y = p.second;
}
inline int sig(double x) { return x < -eps ? -1 : eps < x; }
long long fp(long long a, long long n, long long mod = MOD) {
  if (n < 0) a = fp(a, mod - 2, mod), n = -n;
  long long res = 1;
  for (; n; n >>= 1, a = a * a % mod)
    if (n & 1) res = res * a % mod;
  return res;
}
struct Mint {
  int x;
  Mint() { x = 0; }
  Mint(int _x) : x(_x) {
    if (x < 0 || x >= MOD) x = (x % MOD + MOD) % MOD;
  }
  Mint(long long _x) : x(_x) {
    if (x < 0 || x >= MOD) x = (x % MOD + MOD) % MOD;
  }
  Mint operator-() const { return Mint(MOD - x); }
  Mint operator+(const Mint &rhs) const {
    return Mint(x + rhs.x >= MOD ? x + rhs.x - MOD : x + rhs.x);
  }
  Mint operator-(const Mint &rhs) const {
    return Mint(x - rhs.x < 0 ? x - rhs.x + MOD : x - rhs.x);
  }
  Mint operator*(const Mint &rhs) const {
    return Mint((long long)x * rhs.x % MOD);
  }
  Mint operator/(const Mint &rhs) const {
    return Mint(x * fp(rhs.x, -1) % MOD);
  }
  Mint &operator+=(const Mint &rhs) {
    x += rhs.x;
    if (x >= MOD) x -= MOD;
    return *this;
  }
  Mint &operator*=(const Mint &rhs) {
    x = ((long long)x * rhs.x) % MOD;
    return *this;
  }
  bool operator==(const Mint &rhs) const { return x == rhs.x; }
  bool operator!=(const Mint &rhs) const { return x != rhs.x; }
  friend ostream &operator<<(ostream &out, const Mint &rhs) {
    return out << rhs.x;
  }
  friend istream &operator>>(istream &in, Mint &rhs) { return in >> rhs.x; }
};
const int maxn = (int)2e5 + 20;
const int maxm = (int)1e6 + 20;
void work() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; i++) cin >> a[i];
  sort(a.begin(), a.end());
  int b = 0;
  for (int i = 1; i < n; i++)
    if (a[i - 1] + 1 == a[i]) b = 1;
  int c[2] = {0};
  for (int i = 0; i < n; i++) c[a[i] & 1]++;
  if (c[0] & 1) {
    if (b)
      cout << "YES" << endl;
    else
      cout << "NO" << endl;
  } else {
    cout << "YES" << endl;
  }
}
int main(int argc, char **argv) {
  int tc = 1;
  read(tc);
  for (int ca = 1; ca <= tc; ca++) {
    work();
  }
  return 0;
}

### Prompt

Your challenge is to write a cpp solution to the following problem:

We call two numbers x and y similar if they have the same parity (the same remainder when divided by 2), or if |x-y|=1. For example, in each of the pairs (2, 6), (4, 3), (11, 7), the numbers are similar to each other, and in the pairs (1, 4), (3, 12), they are not.

You are given an array a of n (n is even) positive integers. Check if there is such a partition of the array into pairs that each element of the array belongs to exactly one pair and the numbers in each pair are similar to each other.

For example, for the array a = [11, 14, 16, 12], there is a partition into pairs (11, 12) and (14, 16). The numbers in the first pair are similar because they differ by one, and in the second pair because they are both even.

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.

Each test case consists of two lines.

The first line contains an even positive integer n (2 ≤ n ≤ 50) — length of array a.

The second line contains n positive integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100).

Output

For each test case print:

  * YES if the such a partition exists, 
  * NO otherwise. 



The letters in the words YES and NO can be displayed in any case.

Example

Input


7
4
11 14 16 12
2
1 8
4
1 1 1 1
4
1 2 5 6
2
12 13
6
1 6 3 10 5 8
6
1 12 3 10 5 8


Output


YES
NO
YES
YES
YES
YES
NO

Note

The first test case was explained in the statement.

In the second test case, the two given numbers are not similar.

In the third test case, any partition is suitable.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
  static char _c;
  static bool _f;
  x = 0;
  _f = 0;
  _c = getchar();
  while (_c < '0' || '9' < _c) {
    if (_c == '-') _f = true;
    _c = getchar();
  }
  while ('0' <= _c && _c <= '9') {
    x = (x << 1) + (x << 3) + (_c & 15);
    _c = getchar();
  }
  if (_f) x = -x;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
  read(x);
  read(args...);
}
template <typename T>
inline void Min(T &x, T y) {
  if (y < x) x = y;
}
template <typename T>
inline void Max(T &x, T y) {
  if (x < y) x = y;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double pi = (double)acos(-1.0);
const double eps = (double)1e-8;
const int e5 = (int)1e5 + 5;
const int MOD = (int)1000000007;
template <typename T0, typename T1>
inline void depair(T0 &x, T1 &y, pair<T0, T1> &p) {
  x = p.first, y = p.second;
}
inline int sig(double x) { return x < -eps ? -1 : eps < x; }
long long fp(long long a, long long n, long long mod = MOD) {
  if (n < 0) a = fp(a, mod - 2, mod), n = -n;
  long long res = 1;
  for (; n; n >>= 1, a = a * a % mod)
    if (n & 1) res = res * a % mod;
  return res;
}
struct Mint {
  int x;
  Mint() { x = 0; }
  Mint(int _x) : x(_x) {
    if (x < 0 || x >= MOD) x = (x % MOD + MOD) % MOD;
  }
  Mint(long long _x) : x(_x) {
    if (x < 0 || x >= MOD) x = (x % MOD + MOD) % MOD;
  }
  Mint operator-() const { return Mint(MOD - x); }
  Mint operator+(const Mint &rhs) const {
    return Mint(x + rhs.x >= MOD ? x + rhs.x - MOD : x + rhs.x);
  }
  Mint operator-(const Mint &rhs) const {
    return Mint(x - rhs.x < 0 ? x - rhs.x + MOD : x - rhs.x);
  }
  Mint operator*(const Mint &rhs) const {
    return Mint((long long)x * rhs.x % MOD);
  }
  Mint operator/(const Mint &rhs) const {
    return Mint(x * fp(rhs.x, -1) % MOD);
  }
  Mint &operator+=(const Mint &rhs) {
    x += rhs.x;
    if (x >= MOD) x -= MOD;
    return *this;
  }
  Mint &operator*=(const Mint &rhs) {
    x = ((long long)x * rhs.x) % MOD;
    return *this;
  }
  bool operator==(const Mint &rhs) const { return x == rhs.x; }
  bool operator!=(const Mint &rhs) const { return x != rhs.x; }
  friend ostream &operator<<(ostream &out, const Mint &rhs) {
    return out << rhs.x;
  }
  friend istream &operator>>(istream &in, Mint &rhs) { return in >> rhs.x; }
};
const int maxn = (int)2e5 + 20;
const int maxm = (int)1e6 + 20;
void work() {
  int n;
  cin >> n;
  vector<int> a(n);
  for (int i = 0; i < n; i++) cin >> a[i];
  sort(a.begin(), a.end());
  int b = 0;
  for (int i = 1; i < n; i++)
    if (a[i - 1] + 1 == a[i]) b = 1;
  int c[2] = {0};
  for (int i = 0; i < n; i++) c[a[i] & 1]++;
  if (c[0] & 1) {
    if (b)
      cout << "YES" << endl;
    else
      cout << "NO" << endl;
  } else {
    cout << "YES" << endl;
  }
}
int main(int argc, char **argv) {
  int tc = 1;
  read(tc);
  for (int ca = 1; ca <= tc; ca++) {
    work();
  }
  return 0;
}

```