#define _CRT_SECURE_NO_DEPRECATE
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <fstream>
#include <ctime>
#include <cstring>
#include <functional>
#include <bitset>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
#define pb push_back
#define ppb pop_back
#define pi 3.1415926535897932384626433832795028841971
#define mp make_pair
#define x first
#define y second
#define pii pair<int,int>
#define pdd pair<double,double>
#define INF 1000000000
#define FOR(i,a,b) for (int _n(b), i(a); i <= _n; i++)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;i--)
#define all(c) (c).begin(), (c).end()
#define SORT(c) sort(all(c))
#define rep(i,n) FOR(i,1,(n))
#define rept(i,n) FOR(i,0,(n)-1)
#define L(s) (int)((s).size())
#define C(a) memset((a),0,sizeof(a))
#define VI vector <int>
#define ll long long

inline int fpow(int a, int st, int mod) {
	int ans = 1;
	while (st) {
		if (st % 2) ans = (ll)ans * a % mod;
		a = (ll)a * a % mod;
		st /= 2;
	}
	return ans;
}

int lpr[4000002];
int T = 0;
inline bool prime(int a) {
	if (a == 1) return 0;
	if (a <= 4000000) return lpr[a] == a;
	for (int i = 2; i * i <= a; ++i) {
		++T;
		if (a % i == 0) return 0;
	}
	return 1;
}
int a,b,c,d,n,m,k;
int last_len = -1;
int rev[1 << 17];

// Fast fourier transform with modular arithmetic (so-called NTT - number theoretic transform)
void fft2(int *a, int n, bool invert, int mod, int root, int root_pw) {
	rept(i, n) {
		a[i] %= mod;
		if (a[i] < 0) a[i] += mod;
	}

	int t = -1;
	FORD(i, 20, 0) {
		if (n & 1 << i) {
			t = i;
			break;
		}
	}
	
	if (last_len != t) {
		last_len = t;
		memset(rev, 0, n * sizeof(int));
		rept(i, t) {
			rept(j, 1 << i) {
				rev[j] *= 2;
				rev[j | 1 << i] = rev[j] + 1;
			}
		}
	}

	rept(i, n) {
		if (rev[i] < i) swap(a[i], a[rev[i]]);
	}
 
	for (int len=2; len<=n; len<<=1) {
		int wlen = root;
		for (int i=len; i < root_pw; i<<=1)
			wlen = int (wlen * 1ll * wlen % mod);
		for (int i=0; i<n; i+=len) {
			int w = 1;
			for (int j=0; j<len/2; ++j) {
				int u = a[i+j],  v = int (a[i+j+len/2] * 1ll * w % mod);
				a[i+j] = u+v < mod ? u+v : u+v-mod;
				a[i+j+len/2] = u-v >= 0 ? u-v : u-v+mod;
				w = int (w * 1ll * wlen % mod);
			}
		}
	}
	if (invert) {
		int nrev = fpow(n, mod - 2, mod);
		for (int i=0; i<n; ++i)
			a[i] = int (a[i] * 1ll * nrev % mod);
	}
}

int A1[1 << 17], A2[1 << 17], A3[1 << 17], A4[1 << 17];
inline void multiply(int *A1, int *A2, int n, int mod) {
	// We use two moduli and Chinese remainder theorem, because the result can be quite large
	const int mod1 = 983826433;
	const int root1 = 53;
	const int mod2 = 949616641;
	const int root2 = 137;
	
	memmove(A3, A1, n * sizeof(int));
	memmove(A4, A2, n * sizeof(int));
	fft2(A1, n, 0, mod1, root1, 1 << 17);
	fft2(A2, n, 0, mod1, root1, 1 << 17);
	fft2(A3, n, 0, mod2, root2, 1 << 17);
	fft2(A4, n, 0, mod2, root2, 1 << 17);

	rept(i, n) {
		A1[i] = (ll)A1[i] * A2[i] % mod1;
		A3[i] = (ll)A3[i] * A4[i] % mod2;
	}
	fft2(A1, n, 1, mod1, fpow(root1, mod1 - 2, mod1), 1 << 17);
	fft2(A3, n, 1, mod2, fpow(root2, mod2 - 2, mod2), 1 << 17);
	int r12 = fpow(mod1, mod2 - 2, mod2) % mod2;
	rept(i, n) {
		int x1 = A1[i];
		int x2 = (ll)(A3[i] - x1) * r12 % mod2;
		if (x2 < 0) x2 += mod2;
		A1[i] = (x1 + (ll)x2 * mod1) % mod;
	}
}
void czt2(int *a, int n, int mod, int root, int sroot) {
	int t = 1;
	while (t < n) t *= 2;
	t *= 2;
	rept(i, t) A1[i] = A2[i] = 0;
	int isroot = fpow(sroot, mod - 2, mod);
	rept(i, n) {
		A1[i] = (ll)a[i] * fpow(isroot, i * i, mod) % mod;
		A2[i] = fpow(sroot, i * i, mod);
		if (i) A2[t - i] = A2[i];
	}
	// The problem has been reduced to finding a convolution of two sequences
	multiply(A1, A2, t, mod);
	rept(i, n) {
		a[i] = (ll)A1[i] * fpow(isroot, i * i, mod) % mod;
	}
}

int solve(int *a, int n, int mod, int root) {
	rept(i, n) {
		a[i] %= mod;
		if (a[i] < 0) a[i] += mod;
	}
	int sroot = root;
	root = (ll)root * root % mod;
	// Calculate chirp-z transform and check if there are zeroes in it
	czt2(a, n, mod, root, sroot);
	int ans = 1;
	rept(i, n) ans = (ll)ans * a[i] % mod;
	return ans;
}

int mas[1 << 15], mas2[1 << 15];

inline bool good(int a, int p, int n) {
	if (fpow(a, n, p) != 1) return 0;
	int cur = a;
	rept(z, n - 2) {
		cur = (ll)cur * a % p;
		if (cur == 1) {
			return 0;
			break;
		}
	}
	if (cur == 1) return 0; else
	return 1;
}

int divisors[100001];
int dsize;
// Check if 'a' is a primitive root of unity of order 'n' modulo prime number 'p'
inline bool good2(int a, int p, int n) {
	if (fpow(a, n, p) != 1) return 0;
	if (a == 1) return 0;
	rept(i, dsize) {
		if (fpow(a, divisors[i], p) == 1) return 0;
	}
	return 1;
}
int solve(int *mas, int n, int lim = 3) {
	// Use naive solution for small n
	if (n <= 3) {
		VI p(n);
		rept(i, n) p[i] = i;
		ll ans = 0;
		do {
			ll cur = 1;
			rept(i, n) {
				cur *= mas[(i + p[i]) % n];
			}
			int s = 0;
			rept(i, n) {
				rept(j, i) {
					if (p[j] > p[i]) s ^= 1;
				}
			}
			if (s == 0) ans += cur; else
			ans -= cur;
		} while (next_permutation(all(p)));
		if (!ans) return lim; else
		return 0;
	}
	bool nzero = 0;
	int cnt = 0;
	dsize = 0;
	for (int i = 2; i * i <= 2 * n; ++i) {
		if ((2 * n) % i) continue;
		divisors[dsize++] = i;
		if (i * i != 2 * n) divisors[dsize++] = (2 * n) / i;
	}
	int step = 2 * n;
	// We choose start randomly. Actually, we need to choose all 3 primes randomly, but the current approach works as well.
	int start = 2000000 + (rand() % 32000) * 10 + (rand() % 32000);
	if (n <= 100) start -= 1000000;
	start -= start % step;
	++start;
	// Find a prime number that has a primitive root of unity of order 2*n
	for (int st = start; ; st += step) {
		if (!prime(st)) continue;
		int root = -1;
		for (int j = 2; j <= 1000; ++j) {
			if (j >= st) break;
			if (!good2(j, st, 2 * n)) {
				continue;
			}
			root = j;
			break;
		}
		if (root == -1) continue;
		memmove(mas2, mas, n * sizeof(int));
		int t = solve(mas2, n, st, root);
		if (t) return cnt;
		++cnt;
		if (cnt == lim) return cnt;
	}
	return 0;
}


int main() {
	//freopen("input.txt","r",stdin);
	//freopen("output.txt","w",stdout);
	rep(i, 4000000) lpr[i] = i;
	// Building primes table
	for (int i = 2; i * i <= 4000000; ++i) {
		if (lpr[i] == i) {
			for (int j = i * i; j <= 4000000; j += i) {
				if (i < lpr[j]) lpr[j] = i;
			}
		}
	}

	int kolt;
	scanf("%d", &kolt);
	rep(hod, kolt) {
		scanf("%d", &n);
		rept(i, n) scanf("%d", &mas[i]);
		// We run our algorithm 3 times to decrease the probability of getting a false-positive answer.
		if (solve(mas, n, 3) >= 3) printf("YES\n"); else
		printf("NO\n");
	}
}