#include <bits/stdc++.h>
using namespace std ;
const int mod = 998244353 ;
int norm(int x)
{
	if(x < 0)  x += mod ;
	if(x >= mod)  x -= mod ;
	return x ;
}
template<class T>
T power(T a , int b)
{
	T res = 1 ;
	for( ; b ; b /= 2 , a *= a)
	if(b % 2)  res *= a ;
	return res ;
}
template<class T>
T print(T a , int b)
{
	T res = 1 ;
	for( ; b ; b /= 2 , a *= a)
	if(b % 2)  res *= a ;
	return res ;
}
struct mint
{
	int x ;
	mint(int x = 0) : x(norm(x)) {}
	int val() const
	{
		return x ;
	}
	mint operator-() const
	{
		return mint(norm(mod - x)) ;
	}
	mint inv() const
	{
		assert(x != 0);
		return power(*this, mod - 2) ;
	}
	mint &operator*=(const mint &rhs)
	{
		x = (long long)x * rhs.x % mod ;
		return *this ;
	}
	mint &operator+=(const mint &rhs)
	{
		x = norm(x + rhs.x) ;
		return *this ;
	}
	mint &operator-=(const mint &rhs)
	{
		x = norm(x - rhs.x) ;
		return *this ;
	}
	mint &operator/=(const mint &rhs)
	{
		return *this *= rhs.inv() ;
	}
	friend mint operator*(const mint &lhs , const mint &rhs)
	{
		mint res = lhs ;
		res *= rhs ;
		return res ;
	}
	friend mint operator+(const mint &lhs , const mint &rhs)
	{
		mint res = lhs ;
		res += rhs ;
		return res ;
	}
	friend mint operator-(const mint &lhs , const mint &rhs)
	{
		mint res = lhs ;
		res -= rhs ;
		return res ;
	}
	friend mint operator/(const mint &lhs , const mint &rhs)
	{
		mint res = lhs ;
		res /= rhs ;
		return res ;
	}
} ;
ostream& operator<<(std::ostream& os, const mint& m) 
{
	os << m.x ;
	return os ;
}
vector<mint> fac ;
vector<mint> inv ;
void init(int n)
{
	n <<= 1 ;
	fac.resize(0) ;
	fac.resize(n + 10 , mint(1)) ;
	inv.resize(0) ;
	inv.resize(n + 10 , mint(1)) ;
	for(int i = 2 ; i <= n ; i ++)  fac[i] = fac[i - 1] * i ;
	inv[n] = fac[n].inv() ;
	for(int i = n - 1 ; i >= 1 ; i --)  inv[i] = inv[i + 1] * (i + 1) ;
}
mint C(int n , int m)
{
	if(n < 0 || m < 0 || n < m)  return mint(0) ;
	return fac[n] * inv[m] * inv[n - m] ;
}
using ll = long long ;
struct Linear_base
{
	bool zero ;
	int cnt ;
	ll b[75] , p[75] ;
	void init()
	{
		zero = 0 ;
		cnt = 0 ;
		memset(b , 0 , sizeof(b)) ;
		memset(p , 0 , sizeof(p)) ;
	}
	bool insert(ll x)
	{
		for(int i = 60 ; i >= 0 ; i --)
		if(x & (1ll << i))
		{
			if(b[i])  x ^= b[i] ;
			else  
			{
                cnt += 1 ;
				b[i] = x ;
				return 1 ;
			}
		}
		zero = 1 ;
		return 0 ;
	}
} linear_base ;
mt19937  rnd(chrono::high_resolution_clock::now().time_since_epoch().count()) ;
long long rand_l_r(long long l , long long r)
{
	uniform_int_distribution<long long> dist(l , r) ;
	return dist(rnd) ;
}
void solve()
{
    int n = 1;
    cin >> n ;
    init(n) ;
    vector<int> a(n) ;
    for(int i = 0 ; i < n ; i ++)  cin >> a[i] ;
    sort(a.begin() , a.end()) ;
    vector<int> c(n + 1) ;
    mint ans = 0 ;
    for(int i = 0 ; i < n ; i ++)  c[a[i]] += 1 ;
    vector<mint> f(n + 1 , mint(0)) ;
    for(int i = 1 ; i <= n ; i ++)
    {
        for(int j = 0 ; j <= c[i] ; j += 2)  f[i] += C(c[i] , j) ;
    }
    vector<mint> g(n + 1 , mint(0)) ;
    for(int i = 1 ; i <= n ; i ++)
    {
        for(int j = 1 ; j <= c[i] ; j += 2)  g[i] += C(c[i] , j) ;
    }
    vector<vector<int>> p(n + 1) ;
    for(int i = 1 ; i <= n ; i ++)
        for(int j = i ; j <= n ; j += i)
            p[j].push_back(i) ;
    for(int i = 1 ; i <= n ; i ++)
    {
        mint val = 1 ;
        for(auto u : p[i])
        {
            if(u != i)  val *= f[u] ;
            else  val *= g[u] ;
        }
        // cout << val << "??\n" ;
        ans += val ;

    }
    linear_base.init() ;
    for(auto u : a)  linear_base.insert(u) ;
    if(linear_base.zero)  ans += power(mint(2) , n - linear_base.cnt) - 1 ;
    cout << ans << '\n' ;
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;

    int T ;
    cin >> T ;
    while (T --)  solve() ;
    return 0 ;
}