You are given a sequence of n integers a_1,   a_2,   ...,   a_n.

Does there exist a sequence of n integers b_1,   b_2,   ...,   b_n such that the following property holds?

  * For each 1 ≤ i ≤ n, there exist two (not necessarily distinct) indices j and k (1 ≤ j,   k ≤ n) such that a_i = b_j - b_k. 

Input

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

The first line of each test case contains one integer n (1 ≤ n ≤ 10).

The second line of each test case contains the n integers a_1,   ...,   a_n (-10^5 ≤ a_i ≤ 10^5).

Output

For each test case, output a line containing YES if a sequence b_1,   ...,   b_n satisfying the required property exists, and NO otherwise.

Example

Input


5
5
4 -7 -1 5 10
1
0
3
1 10 100
4
-3 2 10 2
9
25 -171 250 174 152 242 100 -205 -258


Output


YES
YES
NO
YES
YES

Note

In the first test case, the sequence b = [-9,   2,   1,   3,   -2] satisfies the property. Indeed, the following holds: 

  * a_1 = 4 = 2 - (-2) = b_2 - b_5; 
  * a_2 = -7 = -9 - (-2) = b_1 - b_5; 
  * a_3 = -1 = 1 - 2 = b_3 - b_2; 
  * a_4 = 5 = 3 - (-2) = b_4 - b_5; 
  * a_5 = 10 = 1 - (-9) = b_3 - b_1. 



In the second test case, it is sufficient to choose b = [0], since a_1 = 0 = 0 - 0 = b_1 - b_1.

In the third test case, it is possible to show that no sequence b of length 3 satisfies the property.
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp> 
using namespace std; 
using namespace __gnu_pbds;
template<typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
void make_unique(vector<T>& vec) {
 sort(vec.begin(),vec.end());
  vec.erase(unique(vec.begin(),vec.end()), vec.end());
}
void __print(int x) {cerr << x;}void __print(long x) {cerr << x;}void __print(long long x) {cerr << x;}void __print(unsigned x) {cerr << x;}void __print(unsigned long x) {cerr << x;}void __print(unsigned long long x) {cerr << x;}void __print(float x) {cerr << x;}void __print(double x) {cerr << x;}void __print(long double x) {cerr << x;}void __print(char x) {cerr << '\'' << x << '\'';}void __print(const char *x) {cerr << '\"' << x << '\"';}void __print(const string &x) {cerr << '\"' << x << '\"';}void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
/****************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
template <typename T>
inline T gcd(T a, T b) {return b ? gcd(b, a % b) : a;}


#define ll                  long long int
#define mem(a,b)            memset(a,b,sizeof(a))
#define ull                 unsigned long long 
#define precise(ans,digits) fixed<<setprecision(digits)<<ans
#define endl                '\n'
#define ld                  long double
#define pi                  3.141592653589793238
#define fo(i,n)             for(long i=1;i<=n;i++)
#define tol(s)              transform(s.begin(),s.end(),s.begin(),::tolower)
#define tou(s)              transform(s.begin(),s.end(),s.begin(),::toupper)
#define all(x)              (x).begin(), (x).end()
#define pb                  push_back
#define mt                  make_tuple
#define lb                  lower_bound
#define ub                  upper_bound
#define MP                    make_pair
#define tr(it, a)           for(auto it = a.begin();it!=a.end();it++)
#define rtr(it, a)          for(auto it = a.rbegin();it!=a.rend();it++)
#define pq                  priority_queue
#define fr                  first
#define sc                  second
#define sz(x)               (long)x.size()
#define T                   ll t=0;cin>>t;for(ll test=0;test<t;test++)
#define rep(i,n)            for(__typeof(n) i=0; i<(n); i++)
#define MAX(a)              (*max_element(all(a)))
#define MIN(a)              (*min_element(all(a)))
#define bitcount(a)         __builtin_popcountll(a)
#define OS(T)               tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>
#define printclock          cerr<<"Time : "<<1000*(long double)clock()/(long double)CLOCKS_PER_SEC<<"ms\n";
#define get(idx,a)          get<idx>(a)
typedef pair<int, int>     pii;
typedef pair<ll, ll>       pll;
typedef vector<int>        vi;
typedef vector<char>       vc;
typedef vector<vc>         vvc;
typedef vector<ll>         vl;
typedef vector<pii>        vpii;
typedef vector<pll>        vpl;
typedef vector<vi>         vvi;
typedef vector<vl>         vvl; 
typedef pair<ll,pll>       ppl;
//typedef __int128           lll;
 
/*****************************************************************************************************************************************************************************************************************************/
long long add(long long a,long long b,long long mod){long long res=(a%mod+b%mod)%mod;if(res<0)res+=mod;return res;}
long long mul(long long a,long long b,long long mod){  long long res=(a%mod*b%mod)%mod;if(res<0)res+=mod;   return res;}
long long power(long long base, long long exp,long long mod) {    long long res=1; base%=mod; while(exp) {if(exp&1)res=(res*base)%mod;base=(base*base)%mod;exp/=2;}return res%mod;}
long long binpow(long long a, long long b) {    long long res = 1;while (b > 0) {if (b & 1)res = (res*a);a = (a*a);b >>= 1;}return res;}
bool is_prime(long long n){ if (n <= 1)  return false; if (n <= 3)  return true; if (n%2 == 0 || n%3 == 0) return false; for (ll i=5; i*i<=n; i=i+6) {if (n%i == 0 || n%(i+2) == 0) return false; } return true; }
ll lcm(ll a,ll b){ll l=(a*b)/gcd(a,b);return l;}
ll Ceil(ll a, ll b) {return (a/b+(a%b!=0));}
long long inv (long long a,long long mod){return power(a,mod-2,mod);}
long long C(ll n, ll r) {if(n<r)return 0;if(n==r)return 1;if(r > n - r) r = n - r; /*because C(n, r) == C(n, n - r)*/long long ans = 1;ll i;for(i = 1; i <= r; i++) {ans *= n - r + i;ans /= i;}return ans;}
bool ispalindrome(string s) { ll len=s.length(); for(ll i=0;i<len;i++){  if(s[i]!=s[len-i-1]) return false; } return true; }
/*****************************************************************************************************************************************************************************************************************************/

const long long inf=1e15;
const long long M=1000000007;
const long long MM=998244353;
const long long MMM=1000000009;
const ll N=3e5+5;

signed main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif 
   
    
   
   T
   {
       ll n;
       cin>>n;
       set<ll>s;
       vl v(n);
       rep(i,n)
       {
           cin>>v[i];
           v[i]=abs(v[i]);
           s.insert(v[i]);
       }
       if(s.size()<n || s.find(0)!=s.end())
       {
           cout<<"YES\n";
           continue;
       }
       int f=0;
       unordered_map<ll,ll>mp;
       for(ll i=0;i<(1LL<<n);i++)
       {
           if(bitcount(i)<=1)continue;
           bitset<20>b(i);
           ll sum=0;
           for(ll j=0;j<n;j++)
           {
               if(b[j])
               {
                   sum+=v[j];
               }
           }
           if(mp.count(sum))
           {
               f=1;
           }
           mp[sum]++;
       }
    
       debug(v);
       if(f)cout<<"YES\n";
       else cout<<"NO\n";

   }
 




   

   return 0;
}
   




// 2^64-1 use Unsigned long long 