Long time ago there was a symmetric array a_1,a_2,…,a_{2n} consisting of 2n distinct integers. Array a_1,a_2,…,a_{2n} is called symmetric if for each integer 1 ≤ i ≤ 2n, there exists an integer 1 ≤ j ≤ 2n such that a_i = -a_j.

For each integer 1 ≤ i ≤ 2n, Nezzar wrote down an integer d_i equal to the sum of absolute differences from a_i to all integers in a, i. e. d_i = ∑_{j = 1}^{2n} {|a_i - a_j|}.

Now a million years has passed and Nezzar can barely remember the array d and totally forget a. Nezzar wonders if there exists any symmetric array a consisting of 2n distinct integers that generates the array d.

Input

The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases. 

The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).

The second line of each test case contains 2n integers d_1, d_2, …, d_{2n} (0 ≤ d_i ≤ 10^{12}).

It is guaranteed that the sum of n over all test cases does not exceed 10^5.

Output

For each test case, print "YES" in a single line if there exists a possible array a. Otherwise, print "NO".

You can print letters in any case (upper or lower).

Example

Input


6
2
8 12 8 12
2
7 7 9 11
2
7 11 7 11
1
1 1
4
40 56 48 40 80 56 80 48
6
240 154 210 162 174 154 186 240 174 186 162 210


Output


YES
NO
NO
NO
NO
YES

Note

In the first test case, a=[1,-3,-1,3] is one possible symmetric array that generates the array d=[8,12,8,12].

In the second test case, it can be shown that there is no symmetric array consisting of distinct integers that can generate array d.
	
	
	
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.StringTokenizer;


	
		
	
	
	public class COVID {
	
		static long mod = 998244353 ;
		static PrintWriter pw;
			
			static ArrayList<Integer>[] adjList;
			
		static int INF=(int)1e8;
		static double EPS=1e-9;

static int[][][] memo;	
static int n;
static char[] dir;
	public static int dp(int idx , int even,int left) {
		if(idx==n)return 0;
		if(memo[idx][even][left]!=-1)return memo[idx][even][left];
		int ans=1;
		if(left==1&&idx>0) {
		if((even==0&&dir[idx-1]=='L')||(even==1&&dir[idx-1]=='R')) {
			ans+=dp(idx-1,even^1,left);
		}
		}
		if(left==0&&idx<n-1) {
			if((even==0&&dir[idx]=='R')||(even==1&&dir[idx]=='L'))
				ans+=dp(idx+1,even^1,left);
		}
		return memo[idx][even][left]=ans;
	}
public static boolean containD(int num ,int d) {
	while(num!=0) {
		if(num%10==d)return true;
		num/=10;
	}
	return false;
}
public static void main(String[] args) throws Exception {
				Scanner sc = new Scanner(System.in);
				PrintWriter pw = new PrintWriter(System.out);
				int t=sc.nextInt();
				test: while(t-->0) {
					int n=sc.nextInt();
					long[] arr=sc.nextLongArr(2*n);
					HashMap<Long,Integer>map=new HashMap<>();
					for(long num:arr) {
						if(num%2!=0)
							{
							pw.println("NO");
							continue test;
							}
						map.put(num, 1+map.getOrDefault(num, 0));
					}
					Long[] d=new Long[n];
					int idx=0;
					for(Entry<Long, Integer> e: map.entrySet())
						if(e.getValue()!=2)
						{
							pw.println("NO");
							continue test;
						}else {
							d[idx++]=e.getKey();
						}
					Arrays.sort(d);
					if(d[n-1]%(2*n)!=0)
					{
						pw.println("NO");
						continue test;
					
					}
					long a=d[n-1]/(2*n);
					long sufSum=2*a;
				//	ArrayList<Long> ans=new ArrayList<>();
					//ans.add(a);
					//System.out.println(Arrays.toString(d));
					for(int i=n-2;i>=0;i--) {
						long dif=d[i]-(sufSum);
//						if(t==1)
//						System.out.println(dif);
						if(dif<=0||dif%(2*(i+1))!=0)
						{
							pw.println("NO");
							continue test;
								
						}
						dif/=((i+1));
				//		ans.add(dif/2);
						sufSum+=dif;
					}
			//		System.out.println(ans);
					pw.println("YES");
					
				}
				pw.flush();
			}


static ArrayList<Integer> topoSorted;//contains the result of the sorting

public static boolean TopologicalSortBFS() {
	int[] incomingNum=new int[adjList.length];// for each vertex i incomingNum[i]= number of incoming edges
	for(int i=0;i<adjList.length;i++) {
		for(int v:adjList[i])
			incomingNum[v]++;
	}

	Queue<Integer> q= new LinkedList<>();
	int visitedCount=0;
	for(int i=0;i<incomingNum.length;i++)
		if(incomingNum[i]==0)
		{q.add(i);
		}
	while(!q.isEmpty()) {
		int num =q.poll();
		visitedCount++;
		topoSorted.add(num);

		for(int i=0;i<adjList[num].size();i++) {
			if(--incomingNum[adjList[num].get(i)]==0) {
				q.add(adjList[num].get(i));
			}
		}
	}
	if(visitedCount!=adjList.length)return false;// if the number of visited vertices doesn't equal the number of vertices then there 
	// is a cycle in the graph and it can't be topologically sorted 
	return true;
}


static long pow(long p, long e) {
	long ans = 1;
	while (e > 0) {
		if ((e & 1) == 1)
			ans =  ((ans * 1l * p));
		e >>= 1;
		{

		}
		p =  ((p * 1l * p));
	}
	return ans;
}

static long powmod(long b, long e, int mod) {
	long ans = 1;
	b %= mod;
	while (e > 0) {
		if ((e & 1) == 1)
			ans = (int) ((ans * 1l * b) % mod);
		e >>= 1;
		b = (int) ((b * 1l * b) % mod);
	}
	return ans;
}


	public static long add(long a, long b) {
		return (a + b) % mod;
	}

	public static long sub(long a, long b) {
		return (a - b + mod) % mod;
	}

	public static long mul(long a, long b) {
		return ((a % mod) * (b % mod)) % mod;
	}


	
			
			static class longPair implements Comparable<longPair> {
			long x, y;
	
			public longPair(long a, long b) {
				x = a;
				y = b;
			}
	
			public int compareTo(longPair p) {
				return (p.x == x) ? ((p.y == y) ? 0 : (y > p.y) ? 1 : -1) : (x > p.x) ? 1 : -1;
			}
		}
	
	
		static class Pair implements Comparable<Pair> {
			int x;
			int y;
	
			public Pair(int a, int b) {
				this.x = a;
				y = b;
			}
	
	
			public int compareTo(Pair o) {
				return (x == o.x) ? ((y > o.y) ? 1 : (y == o.y) ? 0 : -1) : ((x > o.x) ? 1 : -1);
			}
	
			@Override
	
			public int hashCode() {
				final int prime = 31;
				int result = 1;
				result = prime * result + x;
				result = prime * result + y;
				return result;
			}
	
			@Override
	
			public boolean equals(Object obj) {
				if (this == obj)
					return true;
				if (obj == null)
					return false;
				if (getClass() != obj.getClass())
					return false;
				Pair other = (Pair) obj;
				if (x != other.x)
					return false;
				if (y != other.y)
					return false;
				return true;
			}
	
		}
	
		static class Scanner {
			StringTokenizer st;
			BufferedReader br;
	
			public Scanner(InputStream s) {
				br = new BufferedReader(new InputStreamReader(s));
			}
	
			public Scanner(String s) throws FileNotFoundException {
				br = new BufferedReader(new FileReader(s));
			}
	
			public long[] nextLongArr(int n) throws IOException {
				long[] arr = new long[n];
				for (int i = 0; i < n; i++)
					arr[i] = nextLong();
				return arr;
			}
	
			public int[] nextIntArr(int n) throws IOException {
				int[] arr = new int[n];
				for (int i = 0; i < n; i++)
					arr[i] = nextInt();
				return arr;
			}
	
			public String next() throws IOException {
				while (st == null || !st.hasMoreTokens())
					st = new StringTokenizer(br.readLine(), " ,");
				return st.nextToken();
			}
	
			public int nextInt() throws IOException {
				return Integer.parseInt(next());
			}
	
			public long nextLong() throws IOException {
				return Long.parseLong(next());
			}
	
			public String nextLine() throws IOException {
				return br.readLine();
			}
	
			public double nextDouble() throws IOException {
				String x = next();
				StringBuilder sb = new StringBuilder("0");
				double res = 0, f = 1;
				boolean dec = false, neg = false;
				int start = 0;
				if (x.charAt(0) == '-') {
					neg = true;
					start++;
				}
				for (int i = start; i < x.length(); i++) {
					if (x.charAt(i) == '.') {
						res = Long.parseLong(sb.toString());
						sb = new StringBuilder("0");
						dec = true;
					} else {
						sb.append(x.charAt(i));
						if (dec)
							f *= 10;
					}
					if (sb.length() == 18) {
						res += Long.parseLong(sb.toString()) / f;
						sb = new StringBuilder("0");
					}
				}
				res += Long.parseLong(sb.toString()) / f;
				return res * (neg ? -1 : 1);
			}
	
			public boolean ready() throws IOException {
				return br.ready();
			}
	
		}
	
		public static void shuffle(int[] a) {
			int n = a.length;
			for (int i = 0; i < n; i++) {
				int r = i + (int) (Math.random() * (n - i));
				int tmp = a[i];
				a[i] = a[r];
				a[r] = tmp;
			}
		}
	
	}