#include <bits/stdc++.h>
     
    using namespace std;
     
    const int NMAX = 2000 + 5, MOD = 998244353;
     
    int N;
    vector <int> tree[NMAX];
    int sz[NMAX];
     
    void add(int& where, int value) {
        where += value;
        if (where >= MOD) {
            where -= MOD;
        }
    }
     
    int dp[NMAX][NMAX][2]; //  dp[node][paths][exitPath = 0/1]
    int dp2[NMAX][NMAX][3]; // dp2[sons_used][paths][takenExitPaths = 0/1/2]
     
    void dfs(int node, int father) {
        if (father)
            tree[node].erase(find(tree[node].begin(), tree[node].end(), father));
        for (const auto son: tree[node])
            dfs(son, node);
     
        dp2[0][0][0] = 1;
        for (int son = 0; son < tree[node].size(); ++ son) {
            for (int paths = 0; paths <= sz[node] + sz[tree[node][son]]; ++ paths)
                for (int c = 0; c < 3; ++ c)
                    dp2[son + 1][paths][c] = 0;
            for (int paths = 0; paths <= sz[node]; ++ paths)
                for (int takenExitPaths = 0; takenExitPaths <= 2; ++ takenExitPaths)
                    for (int pathsSon = 0; pathsSon <= sz[tree[node][son]]; ++ pathsSon)
                        for (int exitSon = 0; exitSon < 2; ++ exitSon)
                            if (takenExitPaths + exitSon <= 2)
                                add(dp2[son + 1][paths + pathsSon][takenExitPaths + exitSon], (long long)dp2[son][paths][takenExitPaths] * dp[tree[node][son]][pathsSon][exitSon] % MOD);
            sz[node] += sz[tree[node][son]];
        }
     
        for (int paths = 0; paths <= sz[node]; ++ paths) {
            add(dp[node][paths][0], dp2[tree[node].size()][paths][0]);
            add(dp[node][paths + 1][0], dp2[tree[node].size()][paths][0]);
            add(dp[node][paths + 1][1], dp2[tree[node].size()][paths][0]);
     
            add(dp[node][paths][0], dp2[tree[node].size()][paths][1]);
            add(dp[node][paths][1], dp2[tree[node].size()][paths][1]);
     
            if (paths >= 1)
                add(dp[node][paths - 1][0], dp2[tree[node].size()][paths][2]);
        }
     
        ++ sz[node];
    }
     
    int inverse(int num) {
        int ans = 1;
        while (num != 1) {
            ans = (long long)ans * (MOD - MOD / num) % MOD;
            num = MOD % num;
        }
        return ans;
    }
     
    int test() {
        memset(dp, 0, sizeof dp);
        memset(dp2, 0, sizeof dp2);
        dfs(1, 0);
     
        int ans = 0;
     
        int base = inverse(N * (N + 1) / 2);
        int pw = 1;
        int fact = 1;
        for (int i = 1; i <= N; ++ i) {
            pw = (long long)pw * base % MOD;
            fact = (long long)fact * i % MOD;
            add(ans, (long long)dp[1][i][0] * fact % MOD * pw % MOD);
        }
        return ans;
    }
     
    int main() {
        cin >> N;
        for (int i = 1; i < N; ++ i) {
            int a, b;
            cin >> a >> b;
            tree[a].push_back(b);
            tree[b].push_back(a);
        }
        cout << test() << endl;
    }