description: 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.
solution: //This code is written by प्रविण शंखपाळ 
  
  //package wizard;
  
  import java.io.*;
  import java.math.*;
  import java.util.*;
  import java.text.*;
  
  public class Luna_Lovegood {
  
  	public static void main(String[] args) {
  
  //		try {
  
  		FastReader fr = new FastReader();
  		PrintWriter pt = new PrintWriter(System.out);
  
  		int t = fr.nextInt();
  
  		while (t > 0) {
  
  			int n = fr.nextInt();
  			long A[] = new long[n];
  			for (int i = 0; i < n; i++) {
  				A[i] = fr.nextLong();
  			}
  
  			HashSet<Long> x = new HashSet<>();
  
  			for (int i = 0; i < 1 << n; i++) {
  				long sum = 0;
  				for (int j = 0; j < n; j++) {
  					if ((i & (1 << j)) == 0) {
  						sum += A[j];
  					}
  					x.add(sum);
  				}
  			}
  
  			pt.println(x.size() == 1 << n ? "NO" : "YES");
  
  			t--;
  
  		}
  
  		pt.close();
  
  //		} catch (
  //
  //		Exception e) {
  //			return;
  //		}
  	}
  
  	static int lower_bound(long[] arr, int begin, int end, long tar) {
  		while (begin < end) {
  			int mid = begin + (end - begin) / 2;
  			if (arr[mid] < tar)
  				begin = mid + 1;
  			else if (arr[mid] >= tar)
  				end = mid;
  		}
  		return begin;
  //		lower bound gives largest index of a number smaller than (if target is not present) or equal to target(if target is present) 
  //      for complete array use begin = 0 and end = n
  	}
  
  	static int upper_bound(long[] arr, int begin, int end, long tar) {
  		while (begin < end) {
  			int mid = begin + (end - begin) / 2;
  			if (arr[mid] <= tar)
  				begin = mid + 1;
  			else if (arr[mid] > tar)
  				end = mid;
  		}
  
  		return begin;
  //		upper bound gives smallest index of a number strictly greater than target
  //	    for complete array use begin = 0 and end = n
  	}
  
  	public static void mergeSort(String[] nameGo) {
  		if (nameGo.length > 1) {
  			String[] leftGo = new String[nameGo.length / 2];
  			String[] rightGo = new String[nameGo.length - nameGo.length / 2];
  			for (int so = 0; so < leftGo.length; so++) {
  				leftGo[so] = nameGo[so];
  			}
  			for (int ki = 0; ki < rightGo.length; ki++) {
  				rightGo[ki] = nameGo[ki + nameGo.length / 2];
  			}
  			mergeSort(leftGo);
  			mergeSort(rightGo);
  			merges(nameGo, leftGo, rightGo);
  		}
  	}
  
  	public static void merges(String[] nameH, String[] leftH, String[] rightH) {
  		int as = 0;
  		int bs = 0;
  		for (int i = 0; i < nameH.length; i++) {
  			if (bs >= rightH.length || (as < leftH.length && leftH[as].compareToIgnoreCase(rightH[bs]) < 0)) {
  				nameH[i] = leftH[as];
  				as++;
  			} else {
  				nameH[i] = rightH[bs];
  				bs++;
  			}
  		}
  	}
  
  	static void merge(int arr[], int l, int m, int r) {
  
  		int n1 = m - l + 1;
  		int n2 = r - m;
  
  		int L[] = new int[n1];
  		int R[] = new int[n2];
  
  		for (int i = 0; i < n1; ++i)
  			L[i] = arr[l + i];
  		for (int j = 0; j < n2; ++j)
  			R[j] = arr[m + 1 + j];
  
  		int i = 0, j = 0;
  
  		int k = l;
  		while (i < n1 && j < n2) {
  			if (L[i] <= R[j]) {
  				arr[k] = L[i];
  				i++;
  			} else {
  				arr[k] = R[j];
  				j++;
  			}
  			k++;
  		}
  
  		while (i < n1) {
  			arr[k] = L[i];
  			i++;
  			k++;
  		}
  
  		while (j < n2) {
  			arr[k] = R[j];
  			j++;
  			k++;
  		}
  	}
  
  	static void sort(int arr[], int l, int r) {
  		if (l < r) {
  
  			int m = l + (r - l) / 2;
  
  			sort(arr, l, m);
  			sort(arr, m + 1, r);
  
  			merge(arr, l, m, r);
  		}
  	}
  
  	static class Pair implements Comparable<Pair> {
  		int a, b;
  
  		Pair(int a, int b) {
  			this.a = a;
  			this.b = b;
  		}
  
  		public int compareTo(Pair o) {
  			// TODO Auto-generated method stub
  			if (this.a != o.a)
  				return Integer.compare(this.a, o.a);
  			else
  				return Integer.compare(this.b, o.b);
  			// return 0;
  		}
  
  		public boolean equals(Object o) {
  			if (o instanceof Pair) {
  				Pair p = (Pair) o;
  				return p.a == a && p.b == b;
  			}
  			return false;
  		}
  
  	}
  
  	static int binarySearch(int arr[], int first, int last, int key) {
  		int mid = (first + last) / 2;
  		while (first <= last) {
  			if (arr[mid] < key) {
  				first = mid + 1;
  			} else if (arr[mid] == key) {
  				return mid;
  			} else {
  				last = mid - 1;
  			}
  			mid = (first + last) / 2;
  		}
  		return -1;
  	}
  
  	static class FastReader {
  		BufferedReader br;
  		StringTokenizer st;
  
  		public FastReader() {
  			br = new BufferedReader(new InputStreamReader(System.in));
  		}
  
  		String next() {
  			while (st == null || !st.hasMoreElements()) {
  				try {
  					st = new StringTokenizer(br.readLine());
  				} catch (IOException e) {
  					e.printStackTrace();
  				}
  			}
  			return st.nextToken();
  		}
  
  		int nextInt() {
  			return Integer.parseInt(next());
  		}
  
  		long nextLong() {
  			return Long.parseLong(next());
  		}
  
  		double nextDouble() {
  			return Double.parseDouble(next());
  		}
  
  		String nextLine() {
  			String str = "";
  			try {
  				str = br.readLine();
  			} catch (IOException e) {
  				e.printStackTrace();
  			}
  			return str;
  		}
  	}
  }
  