#include <bits/stdc++.h>
using namespace std;

#define rep(i, N) for (int i = 0; (i) < (int)(N); (i)++)
#define all(x) begin(x), end(x)
#define pb push_back

using ll = long long;
const int K = 26;
const int MOD = 998244353;

int main() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);

    int N; cin >> N;
    vector<int> a(N);
    rep(u, N) cin >> a[u];
    vector<vector<int>> G(N);
    rep(i, N - 1) {
        int x, y;
        cin >> x >> y;
        x--; y--;
        G[x].pb(y);
        G[y].pb(x);
    }

    vector<int> ps;
    vector<int> par(N);
    vector<int> xsum(N);

    vector<int> sz(N, 1);
    auto dfs_sz = [&](auto self, int u, int p) -> void {
        for (int v: G[u]) if (v != p) {
            self(self, v, u);
            sz[u] += sz[v];
        }
    };
    dfs_sz(dfs_sz, 0, -1);

    auto dfs = [&](auto self, int u, int p) -> void {
        par[u] = p;
        xsum[u] ^= a[u];
        sort(G[u].begin(), G[u].end(), [&](int a, int b) { return sz[a] > sz[b]; });
        for (int v: G[u]) if (v != p) {
            xsum[v] = xsum[u];
            self(self, v, u);
        }
        ps.pb(u);
    };
    dfs(dfs, 0, -1);

    {
        vector<int> _a(N);
        rep(u, N) _a[u] = a[ps[u]];
        a = _a;
    }
    {
        vector<int> _xsum(N);
        rep(u, N) _xsum[u] = xsum[ps[u]];
        xsum = _xsum;
    }
    {
        vector<int> ips(N);
        rep(u, N) ips[ps[u]] = u;
        vector<int> _par(N);
        rep(u, N) {
            int p = par[ps[u]];
            _par[u] = p == -1 ? -1 : ips[p];
        }
        par = _par;
    }

    auto calc_A = [&]() -> int {
        ll A = 0;
        rep(i, K) for (int j = i; j < K; j++) {
            int mask = 1<<i | 1<<j;
            vector<int> dp(N);
            ll pair = 0;
            rep(u, N) if ((a[u] & mask) == mask) {
                dp[u]++;
                int p = par[u];
                if (p != -1 && ((a[p] & mask) == mask)) {
                    dp[p] += dp[u];
                } else {
                    pair += (ll)dp[u] * dp[u];
                }
            }
            ll coef = 1LL<<(i + j);
            if (i < j) coef *= 2;
            A = (A + (coef % MOD) * (pair % MOD)) % MOD;
        }
        return A;
    };

    auto calc_O = [&]() -> int {
        ll O = 0;
        vector<ll> unko(K);
        rep(i, K) {
            int mask = 1<<i;
            vector<int> dp(N);
            rep(u, N) if ((a[u] & mask) == 0) {
                dp[u]++;
                int p = par[u];
                if (p != -1 && ((a[p] & mask) == 0)) {
                    dp[p] += dp[u];
                } else {
                    unko[i] += (ll)dp[u] * dp[u];
                }
            }
        }
        rep(i, K) for (int j = i; j < K; j++) {
            int mask = 1<<i | 1<<j;
            vector<int> dp(N);
            ll pair = 0;
            rep(u, N) if ((a[u] & mask) == 0) {
                dp[u]++;
                int p = par[u];
                if (p != -1 && ((a[p] & mask) == 0)) {
                    dp[p] += dp[u];
                } else {
                    pair += (ll)dp[u] * dp[u];
                }
            }
            pair = (ll)N * N - unko[i] - unko[j] + pair;
            ll coef = 1LL<<(i + j);
            if (i < j) coef *= 2;
            O = (O + (coef % MOD) * (pair % MOD)) % MOD;
        }
        return O;
    };

    auto calc_X = [&]() -> int {
        ll X = 0;
        rep(u, N) X = (X + (ll)a[u] * a[u]) % MOD;

        rep(i, K) for (int j = i; j < K; j++) {
            ll pair = 0;
            vector<int> dp00(N);
            vector<int> dp01(N);
            vector<int> dp10(N);
            vector<int> dp11(N);
            rep(u, N) {
                int s = xsum[u] >> i & 1;
                int t = xsum[u] >> j & 1;
                if (s == 0 && t == 0) dp00[u]++;
                if (s == 0 && t == 1) dp01[u]++;
                if (s == 1 && t == 0) dp10[u]++;
                if (s == 1 && t == 1) dp11[u]++;
            }
            rep(u, N) {
                int p = par[u];
                if (p == -1) continue;
                if ((a[p]>>i & 1) == 0 && (a[p]>>j & 1) == 0) {
                    pair += (ll) dp00[p] * dp11[u];
                    pair += (ll) dp01[p] * dp10[u];
                    pair += (ll) dp10[p] * dp01[u];
                    pair += (ll) dp11[p] * dp00[u];
                }
                if ((a[p]>>i & 1) == 0 && (a[p]>>j & 1) == 1) {
                    pair += (ll) dp01[p] * dp11[u];
                    pair += (ll) dp00[p] * dp10[u];
                    pair += (ll) dp11[p] * dp01[u];
                    pair += (ll) dp10[p] * dp00[u];
                }
                if ((a[p]>>i & 1) == 1 && (a[p]>>j & 1) == 0) {
                    pair += (ll) dp10[p] * dp11[u];
                    pair += (ll) dp11[p] * dp10[u];
                    pair += (ll) dp00[p] * dp01[u];
                    pair += (ll) dp01[p] * dp00[u];
                }
                if ((a[p]>>i & 1) == 1 && (a[p]>>j & 1) == 1) {
                    pair += (ll) dp11[p] * dp11[u];
                    pair += (ll) dp10[p] * dp10[u];
                    pair += (ll) dp01[p] * dp01[u];
                    pair += (ll) dp00[p] * dp00[u];
                }
                dp00[p] += dp00[u];
                dp01[p] += dp01[u];
                dp10[p] += dp10[u];
                dp11[p] += dp11[u];
            }
            ll coef = 1LL<<(i + j);
            coef *= 2;
            if (i < j) coef *= 2;
            X = (X + (coef % MOD) * (pair % MOD)) % MOD;
        }
        return X;
    };

    cout << calc_A() << ' ' << calc_O() << ' ' << calc_X() << endl;
}