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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.AbstractCollection;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author sarthakmanna
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        CNezzarAndSymmetricArray solver = new CNezzarAndSymmetricArray();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class CNezzarAndSymmetricArray {
        public void solve(int testNumber, FastReader in, PrintWriter out) {
            int i, j, k;

            int N = in.nextInt() << 1;
            long[] D = in.getLongArray(N);
            Arrays.sort(D);

            myTreeSetLong set = new myTreeSetLong(true);
            for (i = 1; i < N; i += 2) {
                if (D[i] % 2 > 0 || D[i - 1] != D[i]) {
                    out.println("NO");
                    return;
                }
                set.add(D[i]);
            }
            N >>= 1;

            ArrayList<Long> diff = new ArrayList<>();
            for (i = 1; i < set.size(); ++i) {
                long prev = set.elementAtIndex(i - 1);
                long curr = set.elementAtIndex(i);
                long d = curr - prev;

                if (d % (2 * i) > 0 || d == 0) {
                    out.println("NO");
                    return;
                }

                diff.add(d / i / 2);
            }
            Collections.reverse(diff);

            long sum = set.first();
            for (i = 0; i < diff.size() && sum > 0; ++i) {
                sum -= diff.get(i) * (i + 1) * 2;
            }
            if (sum % (2 * N) == 0 && sum > 0) {
                out.println("YES");
            } else {
                out.println("NO");
            }

            System.err.println(sum);
            System.err.println(set);
            System.err.println(diff);
        }

    }

    static class NodeLong {
        NodeLong parent;
        NodeLong left;
        NodeLong right;
        long value;
        int size;
        int height;

        NodeLong(long v) {
            value = v;
            size = height = 1;
        }

        NodeLong finalisePosition(NodeLong root) {
            int lheight = findDepth(left), rheight = findDepth(right);

            if (lheight > rheight + 1) {
                if (findDepth(left.right) > findDepth(left.left))
                    root = left.rotateLeft(root);
                root = rotateRight(root);
            } else if (lheight + 1 < rheight) {
                if (findDepth(right.left) > findDepth(right.right))
                    root = right.rotateRight(root);
                root = rotateLeft(root);
            } else {
                setParameters();
            }

            return root;
        }

        NodeLong rotateRight(NodeLong root) {
            NodeLong A = this, B = left, P = parent;

            if (P != null) {
                if (P.left == this) P.left = B;
                else if (P.right == this) P.right = B;
                else System.exit(7 / 0);
            } else root = B;
            B.parent = A.parent;

            A.left = B.right;
            if (B.right != null) B.right.parent = A;
            B.right = A;
            A.parent = B;

            A.setParameters();
            B.setParameters();

            return root;
        }

        NodeLong rotateLeft(NodeLong root) {
            NodeLong A = this, B = right, P = parent;

            if (P != null) {
                if (P.left == this) P.left = B;
                else if (P.right == this) P.right = B;
                else System.exit(7 / 0);
            } else root = B;
            B.parent = A.parent;

            A.right = B.left;
            if (B.left != null) B.left.parent = A;
            B.left = A;
            A.parent = B;

            A.setParameters();
            B.setParameters();

            return root;
        }

        void setParameters() {
            size = 1 + findSize(left) + findSize(right);
            height = 1 + Math.max(findDepth(left), findDepth(right));
        }

        int size() {
            return size;
        }

        static int findDepth(NodeLong node) {
            return node == null ? 0 : node.height;
        }

        static int findSize(NodeLong node) {
            return node == null ? 0 : node.size();
        }

        public int compareTo(NodeLong node) {
            return Long.compare(value, node.value);
        }

        public String toString() {
            return value + "";
        }

    }

    static class myTreeSetLong implements Iterable<Long> {
        NodeLong root;
        boolean allowDuplicates;
        private int itrInd;
        private ArrayList<NodeLong> dfsTrav = new ArrayList<>();

        public myTreeSetLong() {
            root = null;
        }

        public myTreeSetLong(boolean allowDupli) {
            root = null;
            allowDuplicates = allowDupli;
        }

        public boolean add(long value) {
            return add(new NodeLong(value));
        }

        public long ceiling(long value) {
            return ceiling(new NodeLong(value)).value;
        }

        public long elementAtIndex(int index) {
            if (index < 0 || index >= size()) return 7 / 0;
            else return navigateTo(root, index).value;
        }

        public int size() {
            return root == null ? 0 : root.size();
        }

        public long first() {
            return ceiling(Long.MIN_VALUE);
        }

        private boolean add(NodeLong toAdd) {
            if (root == null) {
                root = toAdd;
                return true;
            }

            NodeLong tr = root;
            while (true) {
                if (toAdd.compareTo(tr) < 0) {
                    if (tr.left == null) {
                        tr.left = toAdd;
                        toAdd.parent = tr;
                        break;
                    } else tr = tr.left;
                } else if (allowDuplicates || toAdd.compareTo(tr) > 0) {
                    if (tr.right == null) {
                        tr.right = toAdd;
                        toAdd.parent = tr;
                        break;
                    } else tr = tr.right;
                } else return false;
            }

            while (toAdd != null) {
                root = toAdd.finalisePosition(root);
                toAdd = toAdd.parent;
            }
            return true;
        }

        private NodeLong ceiling(NodeLong node) {
            if (root == null) return null;

            NodeLong tr = root;
            while (true) {
                if (node.compareTo(tr) < 0) {
                    if (tr.left == null) return tr;
                    else tr = tr.left;
                } else if (node.compareTo(tr) > 0) {
                    if (tr.right == null) return next(tr);
                    else tr = tr.right;
                } else return tr;
            }
        }

        private NodeLong navigateTo(NodeLong node, int ind) {
            if (NodeLong.findSize(node.left) > ind) return navigateTo(node.left, ind);
            ind -= NodeLong.findSize(node.left);
            if (ind == 0) return node;
            ind -= 1;
            return navigateTo(node.right, ind);
        }

        private NodeLong next(NodeLong node) {
            NodeLong parent;

            if (node.right != null) {
                node = node.right;
                while (node.left != null) node = node.left;
                return node;
            }

            while (true) {
                parent = node.parent;
                if (parent == null) return null;
                else if (parent.left == node) return parent;
                else node = parent;
            }
        }

        public Iterator<Long> iterator() {
            dfsTrav.clear();
            dfs(root);
            itrInd = 0;
            Iterator<Long> iterator = new Iterator<Long>() {

                public boolean hasNext() {
                    return itrInd < size();
                }


                public Long next() {
                    return dfsTrav.get(itrInd++).value;
                }
            };
            return iterator;
        }

        private void dfs(NodeLong node) {
            if (node == null) return;
            dfs(node.left);
            dfsTrav.add(node);
            dfs(node.right);
        }

        public String toString() {
            dfsTrav.clear();
            dfs(root);
            if (dfsTrav.isEmpty()) return "[]";
            else return dfsTrav.toString();
        }

    }

    static class FastReader {
        static final int BUFSIZE = 1 << 20;
        static byte[] buf;
        static int index;
        static int total;
        static InputStream in;

        public FastReader(InputStream is) {
            try {
                in = is;
                buf = new byte[BUFSIZE];
            } catch (Exception e) {
            }
        }

        private int scan() {
            try {
                if (index >= total) {
                    index = 0;
                    total = in.read(buf);
                    if (total <= 0)
                        return -1;
                }
                return buf[index++];
            } catch (Exception | Error e) {
                System.err.println(e.getMessage());
                return 13 / 0;
            }
        }

        public String next() {
            int c;
            for (c = scan(); c <= 32; c = scan()) ;
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = scan())
                sb.append((char) c);
            return sb.toString();
        }

        public int nextInt() {
            int c, val = 0;
            for (c = scan(); c <= 32; c = scan()) ;
            boolean neg = c == '-';
            if (c == '-' || c == '+')
                c = scan();
            for (; c >= '0' && c <= '9'; c = scan())
                val = (val << 3) + (val << 1) + (c & 15);
            return neg ? -val : val;
        }

        public long nextLong() {
            int c;
            long val = 0;
            for (c = scan(); c <= 32; c = scan()) ;
            boolean neg = c == '-';
            if (c == '-' || c == '+')
                c = scan();
            for (; c >= '0' && c <= '9'; c = scan())
                val = (val << 3) + (val << 1) + (c & 15);
            return neg ? -val : val;
        }

        public long[] getLongArray(int size) {
            long[] ar = new long[size];
            for (int i = 0; i < size; ++i) ar[i] = nextLong();
            return ar;
        }

    }
}

