Consider a linear function *f*(*x*) = *Ax* + *B*. Let's define *g*<sup class="upper-index">(0)</sup>(*x*) = *x* and *g*<sup class="upper-index">(*n*)</sup>(*x*) = *f*(*g*<sup class="upper-index">(*n* - 1)</sup>(*x*)) for *n* &gt; 0. For the given integer values *A*, *B*, *n* and *x* find the value of *g*<sup class="upper-index">(*n*)</sup>(*x*) modulo 10<sup class="upper-index">9</sup> + 7.
The only line contains four integers *A*, *B*, *n* and *x* (1 ≤ *A*, *B*, *x* ≤ 10<sup class="upper-index">9</sup>, 1 ≤ *n* ≤ 10<sup class="upper-index">18</sup>) — the parameters from the problem statement.

Note that the given value *n* can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
none
3 4 1 1
7
3 4 2 1
25
3 4 3 1
79
1 1 1 1
2
3 10 723 6
443623217
14 81 51 82
908370438
826504481 101791432 76 486624528
621999403
475965351 844435993 96338 972382431
83709654
528774798 650132512 6406119 36569714
505858307
632656975 851906850 1 310973933
230360736
1 1 352875518515340737 1
45212126
978837295 606974665 846646545585165081 745145208
154788991
277677243 142088706 8846851 253942280
221036825
1 192783664 1000000000000000000 596438713
42838179
1 1000000000 1000000000000000000 1
999999665
1 1000000000 1000000000000000000 1000000000
999999657
1 100000000 10000000000000 1000000000
48993
1 1171281 1000000000000000000 100
57392869
1 1000000000 100000000000000000 1000000000
899999965
1 100000000 100000000000000000 10000
490010000
1 100000456 10000000000000000 54165
129054389
1 1000000000 10000000000000 1
490001
1 100000000 10000000000000000 10000
49010000
1 1000000000 10000000000 12
502
1 999999999 999999999999999999 12345678
12345294
1 1000000 1000000000000000000 100000
49100000
1 1000000000 1000000000000 12
49012
1 10000 1000000000000000000 5
490005
1 10000 1000000000000000000 10000
500000
1 1000000000 10000000000000 12
490012
1 1000000000 1000000000000000 12
49000012
1 1000000000 1000000000000000000 12
999999676
1 10000000 100000000000000000 100000
49100000
114514 114514 114514 114514
623380685
2 1 1000000006 1
1
1 1234 10 9
12349
#include <bits/stdc++.h>
using namespace std;

typedef pair<long long int, long long int> ii;
typedef vector<long long int> vi;
typedef vector<vector<long long int>> vvi;
typedef vector<pair<long long int, long long int>> vii;

#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(c) (c).begin(), (c).end()
#define sz(a) ((long long int)(a).size())
#define lli long long int
#define ull unsigned long long int
#define ld long double
#define ref(i, x, y) for (long long int i = (x); i <= (y); ++i)
#define reb(i, x, y) for (long long int i = (x); i >= (y); --i)
#define trf(c, it) for (auto it = (c).begin(); it != (c).end(); ++it)
#define trb(c, it) for (auto it = (c).end() - 1; it != (c).begin() - 1; --it)
#define debs(x) cout << #x << " = " << x << ' '
#define debn(x) cout << #x << " = " << x << '\n'
#define tc(t) int t; cin >> t; while (t--)
#define endl '\n'

const long long int mod = 1e9 + 7;
const long long int pinf = 9223372036854775807;
const long long int ninf = -9223372036854775807;

int main(void)
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	lli n, d[200005], flg, ctr, sm;

	tc(t)
	{
		flg=0; ctr=2; sm=0;
		cin>>n; n*=2;
		ref(i,0,n-1) cin>>d[i];

		sort(d, d+n);

		if (d[n-1]%n!=0) flg++;

		for(int i=0;i<n;i+=2)
		{
			if (d[i]!=d[i+1] || d[i]%2)
				flg++;

			if (i>0)
			{
				if (d[i]==d[i-1]) flg++;
				if ((d[i]-d[i-2])%ctr!=0) flg++;
				else sm+=(d[i]-d[i-2])/ctr;
				ctr+=2;
			}
		}

		if (d[n-1]/n-sm<=0) flg++;
		if (flg==0) cout<<"YES\n";
		else cout<<"NO\n";
	}

	return 0;
}


// WA
// 1. overflow
// 2. re-initialize global variables for every test case
// 3. edge cases like n=1 or some type of cases missing
 
// Run time error
// 1. division by zero
// 2. array bounds
 
// TLE
// 1. move declarations outside
