#include <vector>
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
using ll = long long int;
using Graph = vector< vector<int> >;
const ll MOD = 1000000007;
const int MAXN = 5010;

int N, sz[MAXN+10];
ll pow2[MAXN+10], inv2[MAXN+10], fact[2*MAXN+10], finv[2*MAXN+10];

ll mod_pow(ll n, ll k) {
    ll res = 1;
    for(; k>0; k>>=1) {
        if(k & 1) (res *= n) %= MOD;
        (n *= n) %= MOD;
    }
    return res;
}

void init() {
    fact[0] = 1;
    for(int i=1; i<=2*MAXN; i++) {
        fact[i] = (fact[i-1] * i) % MOD;
    }

    finv[2*MAXN] = mod_pow(fact[2*MAXN], MOD-2);
    for(int i=2*MAXN; i>0; i--) {
        finv[i-1] = (finv[i] * i) % MOD;
    }

    pow2[0] = 1;
    for(int i=1; i<=MAXN; i++) {
        pow2[i] = (pow2[i-1] * 2) % MOD;
    }
    inv2[MAXN] = mod_pow(pow2[MAXN], MOD-2);
    for(int i=MAXN; i>0; i--) {
        inv2[i-1] = (inv2[i] * 2) % MOD;
    }
}

void dfs(Graph &G, int cur, int par=-1) {
    sz[cur] = 1;
    for(auto to : G[cur]) {
        if(to == par) continue;
        dfs(G, to, cur);
        sz[cur] += sz[to];
    }
}

ll comb(int n, int r) {
    if(r < 0 or n < r) return 0;
    return fact[n] * finv[n-r] % MOD * finv[r] % MOD;
}

// M 個の頂点を M / 2 個のペアに分ける方法
ll calc(int M) {
    if(M % 2 == 1) return 0;
    return comb(M, M/2) * fact[M/2] % MOD * inv2[M/2] % MOD;
}

vector< vector<ll> > solve(Graph &G, int cur, int par=-1) {
    vector< vector<ll> > res(2, vector<ll>(sz[cur] + 1));
    auto nxt = res;
    res[0][0] = 1;

    int sum = 0;
    // それぞれの子について、その部分木下で何個使用したか
    for(auto to : G[cur]) {
        if(to == par) continue;
        auto vec = solve(G, to, cur);
        auto even = vec[0], odd = vec[1];

        // vector< vector<ll> > nxt(2, vector<ll>(sz[cur] + 1));
        int M = even.size();
        
        for(int i=sum; i>=0; i--) {
            int bound = sz[cur] - i;
            for(int j=min(M-1, bound); j>=0; j--) {
                
                // もともと (偶数 / 奇数) 個あったところに (偶数 / 奇数) 個のパスを子孫から追加
                // なおかつ、cur と 子の間でパスが通過しないものも考える
                (nxt[0][i+j] += res[0][i] * even[j]) %= MOD;
                (nxt[0][i+j] += res[1][i] * odd [j]) %= MOD;
                (nxt[1][i+j] += res[0][i] * odd [j]) %= MOD;
                (nxt[1][i+j] += res[1][i] * even[j]) %= MOD;

                int rem = sz[to] - j;
                if(rem % 2 == 0 and i+j+rem <= sz[cur]) {
                    // cur と to の間を絶対に選ばないようにする
                    // ここで考慮すべき場合の数は、まだペアにしていない to 以下の頂点がいくつあるかに依存
                    // int mod = ((sz[to] - j) / 2) % 2;
                    /*
                      if(i == 0 and j == 0) {
                      fprintf(stderr, "# rem = %d, odd[%d] = %lld, even[%d] = %lld, calc = %lld\n", rem, j, odd[j], j, even[j], calc(rem));
                      fprintf(stderr, "# res[0][%d] = %lld, res[1][%d] = %lld\n", i, res[0][i], i, res[1][i]);
                      }
                    */
                    (nxt[1][ i+j+rem ] += res[0][i] * even[j] % MOD * calc(rem)) %= MOD;
                    (nxt[1][ i+j+rem ] += res[1][i] * odd [j] % MOD * calc(rem)) %= MOD;
                    (nxt[0][ i+j+rem ] += res[0][i] * odd [j] % MOD * calc(rem)) %= MOD;
                    (nxt[0][ i+j+rem ] += res[1][i] * even[j] % MOD * calc(rem)) %= MOD;

                    /*
                    if(i == 0 and j == 0) {
                        for(int x=0; x<2; x++) {
                            fprintf(stderr, "# rem = %d, dp[%d][%d] = %lld\n", rem, x, i+j+rem, nxt[x][i+j+rem]);
                        }
                    }
                    */
                    
                }
            }
            res[0][i] = res[1][i] = 0;
        }
        sum += sz[to];
        swap(res, nxt);
    }

    // for(int i=0; i<=sz[cur]; i++) {
    //     // 自分の子孫で使用したのが i 個なので、残り sz[i] - i 個
    //     // これが奇数なら無理だし、偶数ならペアにできる
    //     if((sz[cur] - i) % 2 == 0) {
    //         int div = (sz[cur] - i) / 2, mod = (sz[cur] - i) % 2;
    //         for(int k=0; k<2; k++) {
    //             (nxt[(mod + k) % 2][ sz[cur] ] += res[k][i] * calc(div)) %= MOD;
    //         }
    //     }
    //     swap(res, nxt);
    // }

    /*
    fprintf(stderr, "# cur = %d (size = %d)\n", cur, sz[cur]);
    for(int k=0; k<2; k++) {
        for(int i=0; i<=sz[cur]; i++) {
            fprintf(stderr, "dp[%d][%d] = %lld\n", k, i, res[k][i]);
        }
    }
    */
    return res;
}

int main() {
    init();
    cin >> N;

    Graph G(N);
    for(int i=0; i<N-1; i++) {
        int u, v; cin >> u >> v;
        u--; v--;
        G[u].push_back(v);
        G[v].push_back(u);
    }

    dfs(G, 0);
    auto vec = solve(G, 0);
    auto oddVec  = vec[1];
    auto evenVec = vec[0];

    ll ans = 0;
    for(int i=0; i<=N; i++) {
        int rem = N - i;
        if(rem % 2 == 1) continue;

        ll mul = calc(rem);
        {
            ll pls = (mul * evenVec[i]) % MOD;
            ans = (ans + pls + MOD) % MOD;
            // fprintf(stderr, "i = %d, mul = %lld, even = %lld\n", i, mul, evenVec[i]);
        }
        {
            ll sub = (mul * oddVec[i] ) % MOD;
            ans = (ans - sub + MOD) % MOD;
            // fprintf(stderr, "i = %d, mul = %lld, odd  = %lld\n", i, mul, oddVec[i]);
        }
    }
    cout << ans << endl;
    return 0;
}


Measured memory_bytes: 262912