#include <bits/stdc++.h>

using namespace std;

long long powmod(long long x, long long p, int md) {
	long long r = 1;
	while (p) {
		if (p % 2 == 1) r = r * x % md;
		x = x * x % md;
		p /= 2;
	}
	
	return r;
}

const int md = 330301441;

namespace SubsetMEX {
	const int MX = 100000;
	
	int n, cnt[MX + 1];
	
	void read(int _n) {
		memset(cnt, 0, sizeof cnt);
		
		n = _n;
		for (int i = 0, x; i < n; i++) {
			ignore = scanf("%d", &x);
			cnt[x]++;
		}
	}
	
	int countSubsets(int ans[]) {
		int current = powmod(2, n, md), mx = 0;
		for (int i = 0; current != 0; i++) {
			current = current * powmod(2, cnt[i] * (md - 2ll), md) % md;
			ans[i] = current;
			mx = i;
			current = current * (powmod(2, cnt[i], md) - 1) % md;
		}
		
		return mx;
	}
}

namespace XorConvolution {
	const int MXK = 10;
	
	struct Matrix {
		int a[MXK][MXK], n, m;
		
		Matrix(int n, int m) : n(n), m(m) { }
	};
	
	Matrix operator * (Matrix& p, Matrix& q) {
		Matrix result(p.n, q.m);
		for (int i = 0; i < p.n; i++)
			for (int j = 0; j < q.m; j++) {
				long long val = 0;
				for (int k = 0; k < p.m; k++) val += p.a[i][k] * 1ll * q.a[k][j];
				
				result.a[i][j] = val % md;
			}
		
		return result;
	}
	
	Matrix constructMatrix(int k, bool invert) {
		vector<int> divs;
		int x = md - 1;
		for (int i = 2; i * i <= x; i++)
			if (x % i == 0) {
				divs.push_back((md - 1) / i);
				while (x % i == 0) x /= i;
			}
		
		if (x > 1) divs.push_back((md - 1) / x);
		
		int g = 2;
		while (true) {
			bool ok = true;
			for (int d : divs) if (powmod(g, d, md) == 1) ok = false;
			
			if (ok) break;
		
			g++;
		}
		
		int root = powmod(g, (md - 1) / k, md);
		
		Matrix result(k, k);
		for (int i = 0; i < k; i++) {
			int x = powmod(root, invert ? k - i : i, md);
			for (int j = 0; j < k; j++) result.a[i][j] = powmod(x, j, md);
		}
		
		return result;
	}
	
	void transform(int a[], int n, int k, bool invert) {
		Matrix M = constructMatrix(k, invert);
		for (int len = 1; len < n; len *= k)
			for (int i = 0; i < n; i += k * len)
				for (int j = 0; j < len; j++) {
					Matrix V(1, k);
					for (int p = 0; p < k; p++) V.a[0][p] = a[i + j + p * len];
					
					V = V * M;
					
					for (int p = 0; p < k; p++) a[i + j + p * len] = V.a[0][p];
				}
		
		if (invert) {
			long long d = powmod(n, md - 2, md);
			for (int i = 0; i < n; i++) a[i] = a[i] * d % md;
		}
	}
	
	int pow(int a[], int mx, int k, long long p) {
		int m = 1;
		while (m <= mx) m *= k;
		
		transform(a, m, k, false);
		
		for (int i = 0; i < m; i++) a[i] = powmod(a[i], p, md);
		
		transform(a, m, k, true);
	
		return m;
	}
}

const int MX = 1000000;

int cnt[MX];

int main() {
	int T;
	ignore = scanf("%d", &T);
	while (T--) {
		memset(cnt, 0, sizeof cnt);
		
		int n, k;
		long long x;
		ignore = scanf("%d %d %lld", &n, &k, &x);
		
		SubsetMEX::read(n);
		int mx = SubsetMEX::countSubsets(cnt);
		
		mx = XorConvolution::pow(cnt, mx, k, x);

		int sum = accumulate(cnt, cnt + mx, 0ll) % md, ans = 0;
		for (int y = 0; y < mx; y++) {
			long long p = cnt[y] * powmod(sum, md - 2, md) % md;
			p = powmod(p, 3, md) * powmod(y, 2, md) % md;
			ans = (ans + powmod(p, y, md)) % md;
		}
		
		printf("%d\n", ans);
	}
	
	return 0;
}