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.io.*;
import java.util.*;

public class Main {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static PrintWriter pr = new PrintWriter(new OutputStreamWriter(System.out));
	static String readLine() throws IOException {
		return br.readLine();
	}
	static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(readLine());
		return st.nextToken();
	}
	static int readInt() throws IOException {
		return Integer.parseInt(next());
	}
	static long readLong() throws IOException {
		return Long.parseLong(next());
	}
	static double readDouble() throws IOException {
		return Double.parseDouble(next());
	}
	static char readChar() throws IOException {
		return next().charAt(0);
	}
	static class Pair implements Comparable<Pair> {
		int f, s;
		Pair(int f, int s) {
			this.f = f; this.s = s;
		}
		public int compareTo(Pair other) {
			if (this.f != other.f) return this.f - other.f;
			return this.s - other.s;
		}
	}
	final static int M = 1000010;
	static boolean dp[][] = new boolean[2][M<<1];
	static void solve() throws IOException {
		int n = readInt(), a[] = new int[n + 1];
		for (int i = 1; i <= n; ++i) 
			a[i] = Math.abs(readInt());
		Arrays.sort(a, 1, n + 1);
		for (int i = 1, sum = 0; i <= n; ++i) {
			dp[0][M] = dp[1][M] = true;
			for (int j = 1, cur = 1; j <= n; ++j) {
				if (j == i)	continue;
				for (int x = (M<<1) - 1; x - a[j] >= -sum + M; --x) dp[cur][x] |= dp[cur^1][x - a[j]];
				for (int x = 0; x + a[j] <= sum + M; ++x) dp[cur][x] |= dp[cur^1][x + a[j]];
				sum += a[j];
				cur ^= 1;
			}
			boolean flag = dp[(n + 1)&1][a[i] + M];
			Arrays.fill(dp[0], -sum + M, sum + M, false);
			Arrays.fill(dp[1], -sum + M, sum + M, false);
			sum = 0;
			if (flag) {
				pr.println("YES");
				return;
			}
		}
		pr.println("NO");
	}
	public static void main(String[] args) throws IOException {
		//solve();
		for (int t = readInt(); t > 0; --t) solve();
		pr.close();
	}
}
