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 random
import collections
import string
import math
import copy
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)


def input(): return sys.stdin.readline().rstrip("\r\n")


# mo = 998244353
mo = int(1e9+7)


def exgcd(a, b):
    if not b:
        return 1, 0
    y, x = exgcd(b, a % b)
    y -= a//b * x
    return x, y


def getinv(a, m):
    x, y = exgcd(a, m)
    return -1 if x == 1 else x % m


def comb(n, b):
    res = 1
    b = min(b, n-b)
    for i in range(b):
        res = res*(n-i)*getinv(i+1, mo) % mo
        # res %= mo
    return res % mo


def quickpower(a, n):
    res = 1
    while n:
        if n & 1:
            res = res * a % mo
        n >>= 1
        a = a*a % mo
    return res


def dis(a, b):
    return abs(a[0]-b[0]) + abs(a[1]-b[1])


def getpref(x):
    if x > 1:
        return (x)*(x-1) >> 1
    else:
        return 0


def orafli(upp):
    primes = []
    marked = [False for i in range(upp+3)]
    prvs = [i for i in range(upp+3)]
    for i in range(2, upp):
        if not marked[i]:
            primes.append(i)
        for j in primes:
            if i*j >= upp:
                break
            marked[i*j] = True
            prvs[i*j] = j
            if i % j == 0:
                break
    return primes, prvs


def lower_ord(c: str) -> int:
    return ord(c)-97


def upper_ord(c: str) -> int:
    return ord(c) - 65


def read_list():
    return [int(i) for i in input().split()]


def read_int():
    s = input().split()
    if len(s) == 1:
        return int(s[0])
    else:
        return map(int, s)


def ask(s):
    print(f"? {s}", flush=True)


def answer(s):
    print(f"{s}", flush=True)

import functools

# primes, prvs = orafli(100010)

import itertools
from fractions import Fraction


# A = list(map(list,(zip(*A))))


def lowbit(x):
    return -x&x

def pref(x):
    return x*(x+1)>>1

def solve():
    n = read_int()
    arr = read_list()
    if 0 in arr:
        print('YES')
        return
    s = {0}
    bak = arr.pop()
    for i in arr:
        tss = set()
        for j in s:
            tss.add(i+j)
            tss.add(i-j)
            tss.add(j-i)
        s = s.union(tss)
    

    # brr = [0]
    # def dfs(pos):
    #     for pp, k1 in enumerate(brr):
    #         for qq, k2 in enumerate(brr[pp+1:]):
    #             if abs(arr[pos]) == abs(k1-k2):
    #                 # print('YES')
    #                 return 1
    #     if pos == n-1:
    #         return 0
    #     else:
    #         for k in brr:
    #             # tl = []
    #             brr.append(k+arr[pos])
    #             if dfs(pos+1):
    #                 return 1
    #             brr[-1] = k-arr[pos]
    #             if dfs(pos+1):
    #                 return 1
    #             brr.pop()
    #         return 0


                # s.add(brr[-1])
                # for jj in brr[]
    # print(s)
    if bak in s or -bak in s:
        print('YES')
    else:
        print('NO')
    # for p, i in enumerate(arr):
    #     for q, j in enumerate(arr[p+1:]):
    #         s.add(abs(i+j))
    #         s.add(abs(i-j))
    # print(s)
    # if 0 in s:
    #     print('YES')
    #     return
    # if len(s)<pref(n-1)*2:
    #     print('YES')
    #     return
    # print('NO')


    # for pa in itertools.permutations(arr):
    #     brr = [0]
    #     for ppa in pa:
    #         brr = pa + brr[-1]
    #     if brr
    # n, k = read_int()
    # dpp = {}
    # dp = [[0 for i in range(n*2+1)] for j in range(2)]
    # vall = {}
    # for i in range(k):
    #     u, v = read_int()
    #     vall[u] = v
    #     vall[v] = u
    # def dfs(i, j)->int:
    #     if (i, j) in dpp:
    #         return dpp[(i, j)]
    #     else:

        # dp[]
    # for p, i in enumerate(ssl):
        # i.sort()

# fi = open('C:\\cppHeaders\\CF2020.12.17\\test.data', 'r')
# def input(): return fi.readline().rstrip("\r\n")
# primes, prv = orafli(10001)
# solve()
T = int(input())
# t = 1



for ti in range(T):
    solve()
    # except:
        # traceback.print_exc()

