#include <bits/stdc++.h>
#define pii pair<int, int>
#define fi first
#define se second
using namespace std;
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", print_args(__VA_ARGS__)
template <class... T>
void print_args(T... args) { ((cerr << args << ' '), ...) << '\n'; }
typedef long long ll;
const int mod = 998244353, inf = 1e9;
const int N = 4E3 + 5;
ll d[N]; // u点，选了j条边，第j条边选择, 匹配数
ll fac[N], infac[N];
vector<int> g[N];
ll power(ll a, int b, int p) {
    ll res = 1;
    for (; b; b /= 2, a = 1LL * a * a % p) {
        if (b % 2) res = 1LL * res * a % p;
    }
    return res;
}
void init_comb() {
    int len = N - 1;
    fac[0] = 1;
    for (int i = 1; i <= len; i++) fac[i] = 1LL * fac[i - 1] * i % mod;
    infac[len] = power(fac[len], mod - 2, mod);
    for (int i = len - 1; i >= 0; i--) infac[i] = 1LL * infac[i + 1] * (i + 1) % mod;
}
void init() {
    ll t = 1;
    for (int i = 0; i < N; i += 2) { //d[2i]
        d[i] = fac[i] * t % mod * infac[i / 2] % mod;
        t = t * infac[2] % mod;
    }
}
ll dp[N][N][2], siz[N];
void dfs(int u, int f) {
    dp[u][0][0] = 1;
    siz[u] = 1;
    for (auto v : g[u]) {
        if (v == f) continue;
        dfs(v, u);
        // 枚举u子树配对了多少对(<=siz[u]/2)，v子树配对了多少对(siz[v]/2)
        for (int i = siz[u] / 2; ~i; i--) {
            for (int j = 0; j <= siz[v] / 2; j++) {
                if (j > 0) {
                    // u 子树合并 v 子树，u 没选
                    dp[u][i + j][0] += dp[u][i][0] * ((dp[v][j][0] + dp[v][j][1]) % mod) % mod;
                    dp[u][i + j][0] %= mod;
                    // u 已经在字数内被选
                    dp[u][i + j][1] += dp[u][i][1] * ((dp[v][j][0] + dp[v][j][1]) % mod) % mod;
                    dp[u][i + j][1] %= mod;
                }
                // u-v 选
                dp[u][i + j + 1][1] += dp[u][i][0] * dp[v][j][0] % mod;
                dp[u][i + j + 1][1] %= mod;
            }
        }
        siz[u] += siz[v];
    }
}
void solve() {
    int n;
    cin >> n;
    for (int i = 1; i < n * 2; i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dfs(1, 0);
    ll ans = 0;
    // 容斥原理 |A∪B∪C|，将每一棵树边看作一个元素(A,B,C)，最后求的就是树边的贡献之和
    for (int i = 0, j = 1; i <= n; i++, j *= -1) { // 最少有几条树边参与（1~n)
        ll t = (dp[1][i][0] + dp[1][i][1]) % mod; // 贡献了几条树边（i条树边必须选择）
        ans += j * t % mod * d[2 * n - 2 * i] % mod;
        ans %= mod;
        ans = (ans + mod) % mod;
    }
    cout << ans << '\n';
}
signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    init_comb();
    init();

    int _ = 1;
    // cin >> _;
    while (_--) {
        solve();
    }
    return 0;
}