#include <iostream>
#include <map>
#include <vector>
#include <algorithm>

using namespace std;

struct Node;
int get_cnt(Node*);

struct Node {
  array<Node*, 2> children{};
  int cnt{}, val{};
  void update() {
    cnt = val + get_cnt(children[0]) + get_cnt(children[1]);
  }
};

int get_cnt(Node* trie) {
  if (!trie) return 0;
  return trie->cnt;
}

int get_bit(int n, int i) {
  return (n >> i) & 1;
}

const int NUM_LEN = 30;

void insert(Node* trie, int number, int i) {
  if (i == NUM_LEN) {
    trie->val++;
    trie->update();
    return;
  }

  int bit = get_bit(number, NUM_LEN - i - 1);

  if (!trie->children[bit])
    trie->children[bit] = new Node{};

  insert(trie->children[bit], number, i + 1);

  trie->update();
}

const int MOD = 998244353;

int binpow(int a, int b) {
  int res = 1;
  while (b) {
    if (b&1) res = 1ll * res * a % MOD;
    a = 1ll * a * a % MOD;
    b >>= 1;
  }
  return res;
}

int inv(int a) {
  return binpow(a, MOD-2);
}

int n;

int dfs(Node* trie, int eq = 0) {
  if (!trie) {
    return 0;
  }
  
  int ev = 0;
  int cnt = 1ll * get_cnt(trie->children[0]) * get_cnt(trie->children[1]) % MOD;
  // a = 0, b = 1, __builtin_popcnt(lcp) = eq
  ev = (ev + 1ll * cnt * (eq + 1) % MOD) % MOD;
  // a = 1, b = 0, __builtin_popcnt(lcp) = eq
  ev = (ev + 1ll * cnt * (eq + 2) % MOD) % MOD;

  return ((ev + dfs(trie->children[0], eq)) % MOD + dfs(trie->children[1], eq+1)) % MOD;
}

void solve() {
  cin >> n;
  vector<int> s(n);
  map<int, int> cnt;
  for (int& i : s) {
    cin >> i;
    cnt[i]++;
  }
  int ans = 0;
  for (auto [key, val] : cnt) {
    ans = (ans + 1ll * val * val % MOD * max(1, __builtin_popcount(key) + 1) % MOD) % MOD;
  }

  Node* trie = new Node{};
  for (int i : s) {
    insert(trie, i, 0);
  }

  ans = (ans + dfs(trie)) % MOD;
  ans = 1ll * ans * inv(1ll * n * n % MOD) % MOD;
  cout << ans << "\n";
}

signed main() {
  int t = 1;
  cin >> t;
  while (t--) {
    solve();
  }
}