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: from collections import defaultdict, deque, Counter
  from sys import stdin, stdout
  from heapq import heappush, heappop
  import math
  import io
  import os
  import math
  import bisect
  
  #?############################################################
  
  
  def isPrime(x):
      for i in range(2, x):
          if i*i > x:
              break
          if (x % i == 0):
              return False
      return True
  
  #?############################################################
  
  
  def ncr(n, r, p):
      num = den = 1
      for i in range(r):
          num = (num * (n - i)) % p
          den = (den * (i + 1)) % p
      return (num * pow(den, p - 2, p)) % p
  
  
  #?############################################################
  
  def primeFactors(n):
      l = []
      while n % 2 == 0:
          l.append(2)
          n = n / 2
      for i in range(3, int(math.sqrt(n))+1, 2):
          while n % i == 0:
              l.append(int(i))
              n = n / i
      if n > 2:
          l.append(n)
      return list(set(l))
  
  
  #?############################################################
  
  def power(x, y, p):
      res = 1
      x = x % p
      if (x == 0):
          return 0
      while (y > 0):
          if ((y & 1) == 1):
              res = (res * x) % p
          y = y >> 1
          x = (x * x) % p
      return res
  
  #?############################################################
  
  
  def sieve(n):
      prime = [True for i in range(n+1)]
      p = 2
      while (p * p <= n):
          if (prime[p] == True):
              for i in range(p * p, n+1, p):
                  prime[i] = False
          p += 1
      return prime
  
  
  #?############################################################
  
  def digits(n):
      c = 0
      while (n > 0):
          n //= 10
          c += 1
      return c
  
  #?############################################################
  
  
  def ceil(n, x):
      if (n % x == 0):
          return n//x
      return n//x+1
  
  #?############################################################
  
  
  def mapin():
      return [int(x) for x in input().split()]
  
  #?############################################################
  
  
  
  # input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
  # python3 15.py<in>op
  t = int(input())
  for _ in range(t):
      n = int(input())
      l = mapin()
      tt = 3**n
      fl = 0
      for k in range(1, tt):
          temp = k
          sum = 0
          for i in range(n):
              s = temp % 3
              temp //= 3
              if (s == 2):
                  s= -1
                  
              sum += (s * l[i])
          
          if (sum == 0):
              fl = 1
              break
  
          
      if(fl):
          print("YES")
      else:
          print("NO")