Problem: Omkar has received a message from Anton saying "Your story for problem A is confusing. Just make a formal statement." Because of this, Omkar gives you an array a = [a_1, a_2, …, a_n] of n distinct integers. An array b = [b_1, b_2, …, b_k] is called nice if for any two distinct elements b_i, b_j of b, |b_i-b_j| appears in b at least once. In addition, all elements in b must be distinct. Can you add several (maybe, 0) integers to a to create a nice array b of size at most 300? If a is already nice, you don't have to add any elements.

For example, array [3, 6, 9] is nice, as |6-3|=|9-6| = 3, which appears in the array, and |9-3| = 6, which appears in the array, while array [4, 2, 0, 6, 9] is not nice, as |9-4| = 5 is not present in the array.

For integers x and y, |x-y| = x-y if x > y and |x-y| = y-x otherwise.

Input

Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 50), the number of test cases. Description of the test cases follows.

The first line of each test case contains a single integer n (2 ≤ n ≤ 100) — the length of the array a.

The second line of each test case contains n distinct integers a_1, a_2, ⋅⋅⋅, a_n (-100 ≤ a_i ≤ 100) — the elements of the array a.

Output

For each test case, output one line containing YES if Omkar can create a nice array b by adding elements to a and NO otherwise. The case of each letter does not matter, so yEs and nO will also be accepted.

If the first line is YES, output a second line containing a single integer k (n ≤ k ≤ 300). 

Then output one line containing k distinct integers b_1, b_2, ⋅⋅⋅, b_k (-10^9 ≤ b_i ≤ 10^9), the elements of the nice array b. b_1, b_2, ⋅⋅⋅, b_k can be in any order. For each a_i in a, a_i must appear at least once in b.

It can be proved that if Omkar can create such an array b, then he can also do so in a way that satisfies the above constraints.

If multiple solutions exist, you can print any. 

Example

Input


4
3
3 0 9
2
3 4
5
-7 3 13 -2 8
4
4 8 12 6


Output


yes
4
6 0 3 9
yEs
5
5 3 1 2 4
NO
Yes
6
8 12 6 2 4 10

Note

For the first case, you can add integers to a to receive the array b = [6, 0, 3, 9]. Note that |6-3| = |9-6| = |3-0| = 3 and 3 is in b, |6-0| = |9-3| = 6 and 6 is in b, and |9-0| = 9 is in b, so b is nice.

For the second case, you can add integers to a to receive the array b = [5, 3, 1, 2, 4]. We have that |2-1| = |3-2| = |4-3| = |5-4| = 1 is in b, |3-1| = |4-2| = |5-3| = 2 is in b, |4-1| = |5-2| = 3 is in b, and |5-1| = 4 is in b, so b is nice.

For the fourth case, you can add integers to a to receive the array b = [8, 12, 6, 2, 4, 10]. We have that |4-2| = |6-4| = |8-6| = |10-8| = |12-10| = 2 is in b, |6-2| = |8-4| = |10-6| = |12-8| = 4 is in b, |8-2| = |10-4| = |12-6| = 6 is in b, |10-2| = |12-4| = 8 is in b, and |12-2| = 10 is in b, so b is nice.

It can be proven that for all other test cases it is impossible to create a nice array b.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(a,b) for (ll i=a;i<b;i++)
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);

#define nl << '\n'
#define sp << " " <<
const ll MOD = 1e9+7;
 
bool cmp(const pair<ll,ll> &a, const pair<ll,ll> &b){
    
      if(a.first==b.first) return a.second<b.second;
      return (a.first < b.first);
 
 
   // return a.second - a.first  > b.second - b.first;
}
 
 
 
bool isPalindrome(string str){
   
    int l = 0;
    int h = str.size() - 1;
  
   
    while (h > l)
    {
        if (str[l++] != str[h--])
        {
          return false;
        }
    }
    return true;
}
 
ll factorial(ll n){
  
    return (n==1 || n==0) ? 1: n * factorial(n - 1);
}
 
vector<ll> printDivisors(ll n){
    vector<ll> ans;
    
    
    for (int i=1; i<=sqrt(n); i++)
    {
        if (n%i == 0)
        {
            
            if (n/i == i)
              {
                  ans.push_back(i);
              }
 
            else {
                ans.push_back(i);
                ans.push_back(n/i);
            }
              
        }
    }
    return ans;
}
 
 
//  vector<pair<ll,ll>> store;
//  ll setbits(ll n){
     
     
//     ll count=0;
//     ll power=0;
//     while(n){
         
//           if(n & 1==1){
//             store.push_back({pow(2,power),1});
//         }
//          count += n & 1;
//          n >>= 1;
//          power+=1;
        
//     }
    
//     return count;
//  }
 
 
 bool sortcheck(ll a[],ll n){
     
    for(ll i=1;i<n;i++){
        if(a[i-1] + 1 == a[i]){
            continue;
        }
        else{
            return false;
        }
    }
    
    return true;
 }
 
ll gcd(ll a, ll b) { if (a == 0) return b; return gcd(b % a, a); }
 
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
 
  ll binary_expo(ll a, ll b, bool useMod = false) {
    ll res = 1;
    while(b>0) {
        if(b%2) {
            if(useMod) res = (res * a) % MOD;
            else res = (res * a);
        }
        if(useMod) a = (a * a) % MOD;
        else a = (a * a);
        b >>= 1;
    }
    return res;
}
 
 bool  knapSack(ll W, ll wt[] , int n)
{
  
    bool K[n + 1][W + 1];
 
    // Build table K[][] in bottom up manner
    for(ll i = 1; i <= n; i++)
    {
        for(ll w = 1; w <= W; w++)
        {
            if (i == 0 and  w == 0)
                K[i][w] = false;
                
        //   if(i==0 and w!=0){
        //       K[i][w]= false;
        //   }
        //   if(i!=0 || w==0){
        //       K[i][w]= true;
        //   }
           
            if (wt[i - 1] <= w)
                K[i][w] = 
                               ( K[i - 1][w - wt[i - 1]]  || 
                                K[i - 1][w]);
            else
                K[i][w] = K[i - 1][w];
        }
    }
    return K[n][W];
}


ll SieveOfEratosthenes(ll n)
{
   ll count=0;
    bool prime[n + 1];
    memset(prime, true, sizeof(prime));
 
    for (ll p = 2; p * p <= n; p++)
    {
        
        if (prime[p] == true)
        {
            
            for (ll i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
 
    // Print all prime numbers
    for (ll p = 2; p <= n; p++){
        if (prime[p]){
             count+=1;
        }    
        
    }     
    return count;
}




int main() {
    
    fio;
    
    
     ll t;
     cin>>t;
     
     while(t--){
       
       ll n;
       cin>>n;
       
       ll a[n];
       
       
       bool flag=true;
       
       ll mindiff=INT_MAX;
       for(ll i=0;i<n;i++){
           cin>>a[i];
           
           if(a[i]<0){
               flag=false;
           }
       }
       
       
       
       if(flag){
           cout<<"YES" nl;
           
           sort(a , a + n);
           
           ll ma=a[n-1];
           
           
           cout<<ma +  1 <<endl;
           for(ll i=0;i<=ma;i++){
               cout<<i<<" ";
           }
           
           cout<<endl;
       }
       else{
           cout<<"NO" nl;
       }
       
       
     }
  

}