```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t)

	for ; t > 0; t-- {
		var n int
		fmt.Fscan(reader, &n)

		d := make([]int64, 2*n)
		for i := 0; i < 2*n; i++ {
			fmt.Fscan(reader, &d[i])
		}

		sort.Slice(d, func(i, j int) bool {
			return d[i] < d[j]
		})

		// Check conditions:
		// 1. All d values must be even
		// 2. d[i] == d[2n-1-i] (symmetric pairs)
		// 3. The differences d[i+1] - d[i] must be consistent
		// 
		// For a symmetric array sorted as a_1 < a_2 < ... < a_2n,
		// d_i = sum of |a_i - a_j| for all j
		// 
		// After sorting d, d[i] should equal d[2n-1-i]
		// Also, consecutive differences in d should be multiples of 4*(something)
		// 
		// Let's think more carefully:
		// For sorted a: a_1 < a_2 < ... < a_2n
		// d_k = sum_{j<k}(a_k - a_j) + sum_{j>k}(a_j - a_k)
		// d_{k+1} - d_k = (2k - 2n)(a_{k+1} - a_k) * ... 
		// Actually: d_{k+1} - d_k = (2k+1-1 - (2n - 2k - 1)) * ... 
		// Hmm let me reconsider.
		// d_{k+1} - d_k = sum_j |a_{k+1} - a_j| - sum_j |a_k - a_j|
		// For the sorted array, a_{k+1} > a_k
		// diff = (2*(k+1)-1 - 2n + 2*(k+1) - 1) ... 
		// 
		// Standard result: d_{k} (0-indexed) = (2k - 2n + 1) * a_{k+1 sorted} + ...
		// Actually the key insight: after sorting d,
		// 1. d[i] must equal d[2n-1-i]
		// 2. All d[i] must be even
		// 3. The sorted d values, when halved, must have differences that are multiples of 4*(index from center)
		// 
		// Simpler check from competitive programming:
		// Sort d. Check d[i] == d[2n-1-i].
		// Check all d[i] are even.
		// Let e[i] = d[i]/2, for i=0..n-1 (the smaller half)
		// e[i] must be strictly increasing and differences e[i+1]-e[i] must be divisible by (2*(n-i))... 
		// Actually the simplest known check:
		// Sort d, verify d[i]==d[2n-1-i], all even,
		// and the sequence d[0] < d[1] < ... < d[n-1] with d[n-1] < d[n]
		// and differences d[i]-d[i-1] must work out.

		valid := true

		// Check all even and symmetry
		for i := 0; i < 2*n; i++ {
			if d[i]%2 != 0 {
				valid = false
				break
			}
		}

		if valid {
			for i := 0; i < n; i++ {
				if d[i] != d[2*n-1-i] {
					valid = false
					break
				}
			}
		}

		// Check strictly increasing in first half (distinct values needed)
		if valid {
			for i := 0; i < 2*n-1; i++ {
				if d[i] == d[i+1] && !(i == n-1) {
					// d[n-1] == d[n] is required by symmetry, but we need distinct a values
					// Actually d[n-1] < d[n] is NOT required... wait
					// d[n-1] == d[2n-1-(n-1)] = d[n], so they must be equal
				}
			}
			// Actually let's check: first half strictly increasing
			for i := 0; i < n-1; i++ {
				if d[i] >= d[i+1] {
					valid = false
					break
				}
			}
		}

		// Check the difference pattern
		// d[i+1] - d[i] must be divisible by 4 for i in 0..n-2
		// and d[n] - d[n-1] ... d[n] == d[n-1] so diff=0... 
		// Let's check differences of consecutive in first half divisible by 4
		if valid {
			for i := 0; i < n-1; i++ {
				diff := d[i+1] - d[i]
				if diff%4 != 0 {
					valid = false
					break
				}
			}
		}

		if valid {
			fmt.Fprintln(writer, "YES")
		} else {
			fmt.Fprintln(writer, "NO")
		}
	}
}
```