#include<bits/stdc++.h>
using namespace std;
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
  cout << "{"; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "}"; }
const int MOD = 1e9 + 7;
typedef decay<decltype(MOD)>::type T;
struct mi {
    T val;
    explicit operator T() const { return val; }
    mi() { val = 0; }
    mi(const long long& v) {
        val = (-MOD <= v && v <= MOD) ? v : v % MOD;
        if (val < 0) val += MOD; }
    friend ostream& operator<<(ostream& os, const mi& a) { return os << a.val; }
    friend bool operator==(const mi& a, const mi& b) { return a.val == b.val; }
    friend bool operator!=(const mi& a, const mi& b) { return !(a == b); }
    friend bool operator<(const mi& a, const mi& b) { return a.val < b.val; }
    mi operator-() const { return mi(-val); }
    mi& operator+=(const mi& m) {
        if ((val += m.val) >= MOD) val -= MOD;
        return *this; }
    mi& operator-=(const mi& m) {
        if ((val -= m.val) < 0) val += MOD;
        return *this; }
    mi& operator*=(const mi& m) { val = (long long) val * m.val % MOD;
        return *this; }
    friend mi pow(mi a, long long p) {
        mi ans = 1; assert(p >= 0);
        for (; p; p /= 2, a *= a) if (p & 1) ans *= a;
        return ans; }
    friend mi inv(const mi& a) { assert(a != 0); return pow(a, MOD - 2); }
    mi& operator/=(const mi& m) { return (*this) *= inv(m); }
    friend mi operator+(mi a, const mi& b) { return a += b; }
    friend mi operator-(mi a, const mi& b) { return a -= b; }
    friend mi operator*(mi a, const mi& b) { return a *= b; }
    friend mi operator/(mi a, const mi& b) { return a /= b; }
};
const int MAX = 5005;
mi dp[MAX][MAX][2];
mi add[MAX][2][2];
int main(){
    ios_base::sync_with_stdio(0); cin.tie(0);
    int n; cin >> n;
    vector<vector<int>> adj(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v; cin >> u >> v;
        u--; v--;
        adj[u].push_back(v); adj[v].push_back(u);
    }
    vector<mi> ways(n + 5);
    ways[0] = 1;
    for (int i = 2; i < n + 5; i++) {
        ways[i] = ways[i - 2] * (i - 1);
    }
    vector<int> sub(n);
    int root = 0;
    function<void(int, int)> dfs_solve = [&](int src, int par) {
        sub[src] = 1;
        for (int nxt: adj[src]) {
            if (nxt == par) continue;
            dfs_solve(nxt, src);
            sub[src] += sub[nxt];
        }
        if (src != root && adj[src].size() == 1) {
            dp[src][1][0] = 1;
            return;
        }
        for (int nxt: adj[src]) {
            if (nxt == par) continue;
        }
        int to = 1;
        int from = 0;
        for (int i = 0; i <= sub[src]; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0 ; k < 2; k++) {
                    add[i][j][k] = 0;
                }
            }
        }
        add[1][0][from] = 1;
        int sum = 1;
        int cnt = 0;
        for (int nxt: adj[src]) {
            if (nxt == par) continue;
            for (int cur = sum; cur >= 0; cur--) {
                for (int p_cur = 0; p_cur < 2; p_cur++) {
                    if (add[cur][p_cur][from] == 0) continue;
                    for (int up = 0; up <= sub[nxt]; up++) {
                        for (int p_nxt = 0; p_nxt < 2; p_nxt++) {
                            if (dp[nxt][up][p_nxt] == 0) continue;
                            add[cur + up][(p_cur + p_nxt) % 2][to] += add[cur][p_cur][from] * dp[nxt][up][p_nxt];
                        }
                    }
                }
            }
            sum += sub[nxt];
            for (int cur = sum; cur >= 0; cur--) {
                for (int p_cur = 0; p_cur < 2; p_cur++) {
                    add[cur][p_cur][from] = 0;
                }
            }
            to ^= 1, from ^= 1;
            cnt++;
        }
        for (int cur = sub[src]; cur >= 1; cur--) {
            for (int p_cur = 0; p_cur < 2; p_cur++) {
                add[0][p_cur ^ 1][from] += add[cur][p_cur][from] * ways[cur];
            }
        }
        for (int cur = sub[src]; cur >= 0; cur--) {
            for (int p_cur = 0; p_cur < 2; p_cur++) {
                dp[src][cur][p_cur] = add[cur][p_cur][from];
            }
        }
    };
    dfs_solve(root, -1);
    mi ans = 0;
    for (int p = 0; p < 2; p++) {
        ans += dp[root][0][p] * (p ? -1 : 1);
    }
    cout << -ans << '\n';
    return 0;
}


Measured memory_bytes: 200224