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

public class  B{

    static BufferedReader br;
    static  long mod  = 1000000000+7;
    static HashSet<Integer> p  = new HashSet<>();
    public static void main(String[] args) throws Exception {
        br = new BufferedReader(new InputStreamReader(System.in));
        int tc = 1;
        tc = cinI();
        long mod  = (long) (1e9+7);
        while (tc-- > 0) {
            int  n =cinI();

            long[] ar = readArray(2*n,0);
            HashSet<Long> list=  new HashSet<>();
            boolean ok =false;
            for(int i=0;i<2*n;i++){
                list.add(ar[i]);
                if(ar[i]%2!=0){
                    System.out.println("NO");
                    ok=true;
                    break;
                }
            }
            if(ok==true){
                continue;
            }
            ArrayList<Long>   l  =new ArrayList<>();
            for(long c: list){
                l.add(c);
            }
            Collections.sort(l);
            if(l.size()!=n){
                System.out.println("NO");
                continue;
            }
            String p = "YES";
            Long get= l.get(n-1);
            if(get%(2*n)!=0){
                System.out.println("NO");
                continue;
            }
            Long e = get/(2*n);
            long sum = e*2;
            int j= (2*n)-2;
           // System.out.println(sum);
            for(int i=l.size()-2;i>=0;i--){
                Long elem = (l.get(i)-sum)/j;
                if(j==0){
                    p = "NO";
                    break;
                }
                if((l.get(i)-sum)%j!=0){
                  //  System.out.println(l.get(i)-sum+" "+sum);
                    p="NO";
                    break;
                }
                if(elem<=0){
                    p = "NO";
                    break;
                }
                sum +=(elem*2);
                j-=2;
            }
            System.out.println(p);


        }
    }





    static boolean isBad(int[] ff,int[] fr){

        for(int i=0;i<26;i++){
            if(ff[i]>fr[i])return false;
        }
        return true;
    }
















    private static long calP(HashMap<Integer, HashSet<Integer>> graph, boolean[] vis, Stack<Integer> list,
                             long[] cost, long[] dp) {
        int par = list.pop();
        HashSet<Integer> childs = graph.get(par);
        if(childs.size()==0){
            dp[par]=0;
            return dp[par];
        }
        vis[par]=true;
        for(int c: childs){
            if(vis[c]==false){
                list.add(c);
                calP(graph, vis, list, cost, dp);
            }
            if(cost[par]>cost[c]){
                dp[par]=max(dp[par], dp[c]+cost[par]-cost[c]);
            }

        }
        return dp[par];
    }

    public static int max(int[] max) {
        int maxS=0;
        int currSum=0;
        for(int i=0;i<max.length;i++){
            currSum= currSum+max[i];
            maxS=Math.max(maxS,currSum);
        }
        // System.out.println(maxS);
        return maxS;
    }

    private static int dfs(TreeMap<Integer, HashSet<Integer>> graph, boolean[] vis, Integer key, Stack<Integer> st) {
        if(st.size()==0){
            return 0;
        }
        int par= st.pop();

        HashSet<Integer> child = graph.get(par);
        vis[par]=true;
        int nodes=1;
        for(int c:child){
            if(vis[c]==false){
                st.add(c);
                nodes+=dfs(graph,vis,c,st);
            }
        }
        return nodes;
    }


    public static boolean isSorted(int[] arr){

        for(int i=0;i<arr.length-1;i++){
            if(arr[i]>arr[i+1]){
                return false;
            }
        }
        return true;
    }



    private static long gcd(long a, long b) {
        if (a == 0)
            return b;
        if (b == 0)
            return a;

        // base case
        if (a == b)
            return a;

        // a is greater
        if (a > b)
            return gcd(a%b, b);
        return gcd(a, b%a);
    }


    public static long min(long a,long b) {
        return Math.min(a,b);
    }
    public static int min(int a,int b) {
        return Math.min(a,b);
    }
























    public static void sieve(){
        int[] pf = new int[100000000+1];
        //0 prime //1 not prime
        pf[0]=1;
        pf[1]=1;
        for(int j=2;j<=10000;j++){

            if(pf[j]==0 ){
                p.add(j);
                for(int k=j*j;k<pf.length;k+=j){
                    pf[k]=1;
                }
            }
        }

    }






    public  static  int[] readArray(int n,int x ,int z)throws Exception{
        int[] arr= new int[n];
        String[] ar= cinA();
        for(int i =x ;i<n+x;i++){
            arr[i]=getI(ar[i-x]);
        }
        return arr;
    }
    public  static  long[] readArray(int n,int x )throws Exception{
        long[] arr= new long[n+x];
        String[] ar= cinA();
        for(int i =x ;i<n+x;i++){
            arr[i]=getL(ar[i-x]);
        }
        return arr;
    }

    public static void arrinit(String[] a,long[] b)throws Exception{
        for(int i=0;i<a.length;i++){
            b[i]=Long.parseLong(a[i]);
        }
    }
    public  static HashSet<Integer>[]  Graph(int n,int edge,int directed)throws Exception{
        HashSet<Integer>[] tree=  new HashSet[n];

        for(int j=0;j<edge;j++){

            String[] uv = cinA();
            int u = getI(uv[0]);
            int v = getI(uv[1]);
            if(directed==0){

                tree[v].add(u);
            }
            tree[u].add(v);
        }
        return tree;
    }
    public static void arrinit(String[] a,int[] b)throws Exception{
        for(int i=0;i<a.length;i++){
            b[i]=Integer.parseInt(a[i]);
        }
    }


    static double findRoots(int a, int b, int c) {
        // If a is 0, then equation is not
        //quadratic, but linear


        int d = b * b - 4 * a * c;
        double sqrt_val = Math.sqrt(Math.abs(d));


        // System.out.println("Roots are real and different \n");

        return Math.max((double) (-b + sqrt_val) / (2 * a),
                (double) (-b - sqrt_val) / (2 * a));


    }

    public static String cin() throws Exception {
        return br.readLine();
    }

    public static String[] cinA() throws Exception {
        return br.readLine().split(" ");
    }
    public static String[] cinA(int x) throws Exception{
        return br.readLine().split("");
    }

    public static String ToString(Long x) {
        return Long.toBinaryString(x);
    }

    public static void cout(String s) {
        System.out.println(s);
    }

    public static Integer cinI() throws Exception {
        return Integer.parseInt(br.readLine());
    }

    public static int getI(String s) throws Exception {
        return Integer.parseInt(s);
    }

    public static long getL(String s) throws Exception {
        return Long.parseLong(s);
    }

    public static long max(long a, long b) {
        return Math.max(a, b);
    }
    public static int max(int a, int b) {
        return Math.max(a, b);
    }

    public static void coutI(int x) {
        System.out.println(String.valueOf(x));
    }

    public static void coutI(long x) {
        System.out.println(String.valueOf(x));
    }

    public static Long cinL() throws Exception {
        return Long.parseLong(br.readLine());
    }

    public static void arrInit(String[] arr, int[] arr1) throws Exception {
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = getI(arr[i]);
        }

    }
}