#include <iostream>
#include <vector>
#include <array>
using namespace std;
using ll = long long;
#define rep(i,a) for (ll i = 0; i < (a); i++)
#define rrep(i,a) for (ll i = (a)-1; i >= 0; i--)
#include "atcoder/modint.hpp"
using mint = atcoder::modint998244353;

template <typename T>
void fwht(vector<T> &v, bool inv = false) {
    const int n = int(v.size());
    assert((n & (n-1)) == 0);
    for (int i = 1; i < n; i <<= 1) {
        for (int j = 0; j < n; j += i << 1) {
            for (int k = 0; k < i; k++) {
                T s = v[j+k], t = v[j+k+i];
                v[j+k] = s+t;
                v[j+k+i] = s-t;
            }
        }
    }
    if (inv) {
        // T inv_n = T(1) / n;
        // for (auto& x : v) x *= inv_n;
        for (auto &x : v) x /= n;
    }
}

template <typename T>
vector<T> bitwise_xor_convolution(vector<T> f, vector<T> g) {
    assert(f.size() == g.size());
    const int n = int(f.size());
    assert((n & (n-1)) == 0);
    fwht(f,false); fwht(g,false);
    for(int i = 0; i < n; i++) f[i] *= g[i];
    fwht(f, true);
    return f;
}

constexpr int B = 18;
constexpr int M = 1<<B;

int main() {
    int n; cin >> n;
    vector<ll> a(n);
    rep(i,n) cin >> a[i];
    vector<ll> f(M);
    rep(i,n) f[a[i]]++;
    vector<ll> ff = bitwise_xor_convolution(f,f);
    mint ans_sum = 0;
    rep(x,M) ans_sum += mint(x)*ff[x] * (n-2)*(n-3)*2;
    vector<mint> sum_f(M+1), sum_fi(M+1);
    rep(i,M) sum_f[i+1] += sum_f[i] + ff[i];
    rep(i,M) sum_fi[i+1] += sum_fi[i] + ff[i] * i;

    mint ans_min = 0;
    rep(x,M) {
        ans_min += mint(ff[x]) * (x*(sum_f[M] - sum_f[x]) + sum_fi[x]);
        ans_min += ff[x]*x*2;
    }

    ll ax[B][2][B][2] = {{{{0}}}};
    rep(i,n)rep(j,B)rep(k,B) ax[j][a[i]>>j&1][k][a[i]>>k&1]++;
    int ay[M*2][B][2] = {{{0}}};
    //vector<vector<vector<int>>> ay(M*2, vector<vector<int>> (B, vector<int>(2)));
    rep(i,n)rep(j,B) ay[M+a[i]][j][a[i]>>j&1]++;
    ll b[B][2] = {{0}};
    rep(i,M)rep(j,B) b[j][i>>j&1] += f[i]*f[i];

    rrep(s,M){
        if(s == 0) continue;
        rep(i,B)rep(j,2) ay[s][i][j] += ay[s*2][i][j] + ay[s*2+1][i][j];
        int d = B - (32 - __builtin_clz(s));
        mint s0 = ay[s*2][0][0] + ay[s*2][0][1];
        mint s1 = ay[s*2+1][0][0] + ay[s*2+1][0][1];
        rep(i,B){
            mint cnt = ax[d][1][i][0] * ay[s*2+1][i][1] + ax[d][1][i][1] * ay[s*2+1][i][0];
            ans_min -= 4 * 2 * s0 * cnt * (1<<i);
            cnt = ax[d][0][i][0] * ay[s*2][i][1] + ax[d][0][i][1] * ay[s*2][i][0];
            ans_min -= 4 * 2 * s1 * cnt * (1<<i);
        }
    }
    rep(i,n)rep(j,B) ans_min -= mint(b[j][1-(a[i]>>j&1)]) * (1<<j) * 4;
    mint ans = ans_sum - ans_min*2;
    cout << ans.val() << "\n";
}