#include <bits/stdc++.h>

using namespace std;
#define int __int128
#define rep(i, a, b) for(int i=(a);i<=(b);++i)
#define per(i, a, b) for(int i=(a);i>=(b);--i)
#define IOS std::ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define vv vector
#define sz(x) (int)x.size()
#define endl "\n"
const int inf = 1e18, N = 3e5 + 5, mod = 998244353, m1 = 1;

int qpw(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

namespace my128 {
    using i64 = __int128_t;

    i64 abs(const i64 &x) {
        return x > 0 ? x : -x;
    }

    auto &operator>>(istream &it, i64 &j) {
        string val;
        it >> val;
        reverse(val.begin(), val.end());
        i64 ans = 0;
        bool f = 0;
        char c = val.back();
        val.pop_back();
        for (; c < '0' || c > '9'; c = val.back(), val.pop_back()) {
            if (c == '-') {
                f = 1;
            }
        }
        for (; c >= '0' && c <= '9'; c = val.back(), val.pop_back()) {
            ans = ans * 10 + c - '0';
        }
        j = f ? -ans : ans;
        return it;
    }

    auto &operator<<(ostream &os, const i64 &j) {
        string ans;
        function<void(i64)> write = [&](i64 x) {
            if (x < 0) ans += '-', x = -x;
            if (x > 9) write(x / 10);
            ans += x % 10 + '0';
        };
        write(j);
        return os << ans;
    }
}
using namespace my128;

int inv(int x) { return qpw(x, mod - 2); }

void solve() {
    int n;
    cin >> n;
    vv<vv<int>> g(n + 1);
    rep(i, 1, n - 1) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    vv<int> siz(n + 1), maxs(n + 1), del(n + 1);
    vv<int> dist(n + 1), siz2(n + 1), val(n + 1);
    int ans = 0;
    auto sol = [&](auto &&self, int u, int s) -> void {
        int ms = s + 1, rt = -1;
        auto dfs1 = [&](auto &&self, int u, int pr) -> void {
            siz[u] = 1;
            maxs[u] = 0;

            dist[u] = 0;
            siz2[u] = 0;
            val[u] = 0;
            for (int v: g[u]) {
                if (del[v] || v == pr) continue;
                self(self, v, u);
                siz[u] += siz[v];
                maxs[u] = max(maxs[u], siz[v]);
            }
            maxs[u] = max(maxs[u], s - maxs[u]);
            if (maxs[u] < ms) ms = maxs[u], rt = u;
        };
        dfs1(dfs1, u, 0);

        int sum1 = 0, sum2 = 0, sum3 = 0;
        int totSiz = 1, Siz2 = 0;
        for (int v: g[rt]) {
            if (del[v]) continue;
            auto dfs = [&](auto &&self, int u, int pr) -> void {
                dist[u] = dist[pr] + 1;
                siz2[u] = 1;
                siz[u] = 1;
                for (int v: g[u]) {
                    if (v == pr || del[v]) continue;
                    self(self, v, u);
                    siz2[u] += siz2[v];
                    siz[u] += siz[v];
                }
            };
            dfs(dfs, v, rt);
            (Siz2 += siz2[v] * siz2[v] % mod) %= mod;
            (totSiz += siz2[v]);
            auto dfs2 = [&](auto &&self, int u, int pr) -> void {
                val[u] = siz2[u] * siz2[u] % mod;
                for (int v: g[u]) {
                    if (v == pr || del[v]) continue;
                    self(self, v, u);
                    val[u] = (val[u] - siz2[v] * siz2[v] % mod + mod) % mod;
                }
            };
            dfs2(dfs2, v, rt);

            auto dfs3 = [&](auto &&self, int u, int pr) -> void {
                ans += sum1 * dist[u] * dist[u] % mod * val[u] % mod;
                ans %= mod;
                ans += sum2 * val[u] % mod;
                ans %= mod;
                ans += dist[u] * val[u] % mod * sum3 % mod;
                ans %= mod;
                for (int v: g[u]) {
                    if (v == pr || del[v]) continue;
                    self(self, v, u);
                }
            };
            dfs3(dfs3, v, rt);
            auto dfs4 = [&](auto &&self, int u, int pr) -> void {
                (sum1 += val[u]) %= mod;
                (sum2 += dist[u] * dist[u] % mod * val[u] % mod) %= mod;
                (sum3 += dist[u] * val[u] % mod * 2 % mod) %= mod;
                for (int v: g[u]) {
                    if (v == pr || del[v]) continue;
                    self(self, v, u);
                }
            };
            dfs4(dfs4, v, rt);
        }
        int out=n-totSiz;
        totSiz=n;(Siz2+=out*out%mod)%=mod;
        for (int v: g[rt]) {
            if (del[v]) continue;
            int totSiz2 = totSiz - siz2[v], siz22 = (Siz2 - siz2[v] * siz2[v] % mod + mod) % mod;
            int ret = (totSiz2 * totSiz2 % mod - siz22 + mod) % mod;
            auto dfs = [&](auto &&self, int u, int pr) -> void {
                ans = (ans + ret * dist[u] % mod * dist[u] % mod * val[u] % mod) % mod;
                for (int v: g[u]) {
                    if (v == pr || del[v]) continue;
                    self(self, v, u);
                }
            };
            dfs(dfs, v, rt);
        }
        del[rt] = 1;
        for (auto v: g[rt]) {
            if (del[v]) continue;
            self(self, v, siz[v]);
        }
    };
    sol(sol, 1, n);
    int tot = (n * (n - 1) / 2 % mod) * (n * (n - 1) / 2 % mod) % mod;
    cout << ans * inv(tot) % mod << endl;
}

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