#include <bits/stdc++.h>

using namespace std;
#define ll long long
#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 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 N = 5005, mod = 998244353, inf = 2e9;

int f[N];

int qpow(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 x) {
    return qpow(x, mod - 2);
}

int C(int n, int m) {
    if (n < m) return 0;
    return 1LL * f[n] * inv(f[n - m]) % mod * inv(f[m]) % mod;
}

void add(int &x, int y) {
    x = (1LL * x + y + mod) % mod;
}

void solve() {
    int n;
    cin >> n;
    n *= 2;
    vv<vv<int>> adj(n + 1);
    rep(i, 1, n - 1) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    int sum = 0;

    vv dp(n + 5, vv(n + 5, vv<int>(2)));
    vv g(n + 5, vv<int>(2));
    vv<int> siz(n + 1);
    function<void(int, int)> dfs = [&](int u, int pr) {
        siz[u] = 1;
        dp[u][0][0] = 1;
        for (int v: adj[u]) {
            if (v == pr) continue;
            dfs(v, u);
            per(i, siz[u], 0)rep(j, 0, siz[v]) {
                    add(g[i + j][0],
                        1LL * dp[u][i][0] * (dp[v][j][0] + dp[v][j][1]) % mod);
                    add(g[i + j][1],
                        1LL * dp[u][i][1] * (dp[v][j][0] + dp[v][j][1]) % mod);
                    add(g[i + j + 1][1],
                        1LL * dp[u][i][0] * (dp[v][j][0]) % mod);
                }
            siz[u] += siz[v];
            rep(i, 0, siz[u]) {
                rep(j, 0, 1) {
                    dp[u][i][j] = g[i][j];
                    g[i][j] = 0;
                }
            }
        }
    };
    dfs(1, 0);

    rep(i, 0, n - 1) {
        if (n / 2 - i < 0) break;
        add(sum, 1LL * (1LL * dp[1][i][0] + dp[1][i][1]) % mod *
                 C(n - 2 * i, n / 2 - i) % mod * f[n / 2 - i] % mod *
                 inv(qpow(2, n / 2 - i) % mod) % mod * qpow(-1, i));
    }
    cout << sum << endl;
}

signed main() {
    IOS
    f[0] = 1;
    rep(i, 1, N - 1) {
        f[i] = 1LL * f[i - 1] * i % mod;
    }
    int64_t tt = 1;
    //cin >> tt;
    rep(kase, 1, tt) solve();
}