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.
import java.util.*;
import java.io.*;
public class Sol{
 
/*   
->check n=1, int overflow , array bounds , all possibilites(dont stuck on 1 approach)
->Problem = Observation(constraints(m<=n/3 or k<=min(100,n)) 
           + Thinking + Technique (seg_tree,binary lift,rmq,bipart,dp,connected comp etc)
->solve or leave it (-solution improves you in minimal way-)
*/
 
public static void main (String []args)  
   throws IOException {
//precomp();

int times=ni();while(times-->0){solve();}out.close();}

static void solve() throws IOException{  
     int n=ni();
     int a[]=new int[n];
     for(int i=0;i<n;i++){a[i]=ni();if(a[i]<0)a[i]*=-1;
       //out.print(a[i]+" ");
     }//out.println();
 
     ArrayList<Integer> al=new ArrayList<>();
     HashSet<Integer> hs=new HashSet<>();al.add(0);hs.add(0);
 
     for(int i=0;i<n;i++){
        int cn=al.size();
        for(int j=0;j<cn;j++){
           int curr=al.get(j)+a[i];///out.println();
           if(hs.contains(curr)){out.println("YES");return;}
           al.add(curr);
           hs.add(curr);
        }
     }
     //out.println(al);
     out.println("NO");
     return;
 }


//-----------------Utility--------------------------------------------

static class Seg{int l,r;Seg(int l,int r){this.l=l;this.r=r;}}

static int st[],lazy[];

static void point_update(int i,int v){
    st[i]=v;int j=i/2;
    while(j>=1){
      st[j]=Math.min(st[2*j],st[2*j+1]);j/=2;
    }
 }

static void prop(int i,int l,int r){
   if(l!=r)
   {lazy[2*i+1]+=lazy[i];lazy[2*i]+=lazy[i];}st[i]+=lazy[i];lazy[i]=0; 
 }

static void update(int i,int l,int r,int L,int R,int v){
   prop(i,l,r);
   if(L>r || l>R)return;
   if(L<=l && R>=r){lazy[i]+=v;return;}
   int mid=(l+r)/2;
   update(2*i,l,mid,L,R,v);update(2*i+1,mid+1,r,L,R,v);
   st[i]=Math.min(st[2*i]+lazy[2*i],st[2*i+1]+lazy[2*i+1]);
   
 }

static long gcd(long a,long b){if(b==0)return a; return gcd(b,a%b);}
 
static int Max=Integer.MAX_VALUE; static long mod=1000000007;
 
static int v(char c){return (int)(c-'a');}
 
public static long power(long x, long y )
    {
        //0^0 = 1
        long res = 1L;
        x = x%mod;
        while(y > 0)
        {
            if((y&1)==1)
                res = (res*x)%mod;
            y >>= 1;
            x = (x*x)%mod;
        }
        return res;
    }
 
static class Pair implements Comparable<Pair>{
        int id;int value;Pair next;
        public Pair(int id,int value) {
         
          this.id=id;this.value=value;next=null;
        }
        @Override
        public int compareTo(Pair p){return Long.compare(value,p.value);}
    }
 
//----------------------I/O---------------------------------------------
 
static PrintWriter out=new PrintWriter(System.out);
static Reader in=new Reader();

static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
 
        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
 
        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(
                new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
 
        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    if (cnt != 0) {
                        break;
                    }
                    else {
                        continue;
                    }
                }
                buf[cnt++] = (byte)c;
            }
            return new String(buf, 0, cnt);
        }
 
        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
 
            if (neg)
                return -ret;
            return ret;
        }
 
        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
 
        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
 
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
 
            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }
 
            if (neg)
                return -ret;
            return ret;
        }
 
        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0,
                                 BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
 
        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
 
        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
static int ni() throws IOException{return in.nextInt();} 
static long nl() throws IOException{return in.nextLong();}
static double nd() throws IOException{return in.nextDouble();}
static String ns() throws IOException{return in.readLine();}
//---------------------I/O------------------------------------------------- 
}