#include <bits/stdc++.h>
#include <chrono>
#include <random>
#include<iomanip>
using std::cin;
using std::cout;
using std::cerr;
using std::deque;
using std::endl;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::swap;
using std::vector;
using std::ios_base;
using std::ostream;
using std::istream;
using std::string;
using std::fill;
using std::sort; 

typedef unsigned int ui;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;                    
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
#define pb push_back
#define pf push_front
#define rb pop_back
#define rf pop_front

#define MOD(a, b) a %= b; if(a < 0) a += b;


class IntModular
{
public:
	typedef long long ll;
	IntModular(int m): _m(m){}
	int operator()(int x) const {		MOD(x, _m);		return x;	}
	int operator()(ll x) const {		MOD(x, _m);		return x;} 
	int plus(int a, int b)const{		return (*this)(a + b);	}
	int plus(ll a, ll b)const{		return (*this)(a + b);	}
	int subtract(int a, int b)const{		return (*this)(a - b);	}
	int subtract(ll a, ll b)const{		return (*this)(a - b);	}
	int mul(int a, int b)const{		return (*this)((ll)a * b);	}
	int mul(ll a, ll b)const{		return mul((*this)(a), (*this)(b));	}
private:
	int _m;   
};


class LongModular
{
public:
	typedef long long ll;
	typedef long double ld;
	ll operator()(ll x)    {    	MOD(x, _m);    	return x;    }
    ll plus(ll a, ll b)    {    	return (*this)(a + b);    }
    ll subtract(ll a, ll b)    {    	return (*this)(a - b);    }
    ll mul(ll a, ll b)    {    	ll k = ll((ld) a * b / _m);    	ll ans = (a * b - k * _m);    	MOD(ans, _m);    	return ans;    }
private:
	ll _m;		
};

template<int M>
class Remainder
{
public:
	typedef long long ll;
	Remainder(): _v(0){}
	Remainder(int v): _v(v){MOD(_v, M)}
	Remainder(ll v)	{MOD(v, M);	_v = v;	}
	Remainder(const Remainder<M>& x): _v(x._v){}
	Remainder<M>& operator=(Remainder<M> &x){_v = x._v; return *this;}
	Remainder<M>& operator=(const Remainder<M> &x){_v = x._v; return *this;}
	Remainder<M> operator+(const Remainder<M> &x) const{return _v + x._v;}
	Remainder<M> operator-(const Remainder<M> &x) const{return _v - x._v;}
	Remainder<M> operator*(const Remainder<M> &x) const{return (ll)_v * x._v;}
	Remainder<M> &operator+=(Remainder<M> &x){_v += x._v; MOD(_v, M); return *this;}
	Remainder<M> &operator-=(Remainder<M> &x){_v -= x._v; MOD(_v, M); return *this;}
	Remainder<M> &operator+=(const Remainder<M> &x){_v += x._v; MOD(_v, M); return *this;}
	Remainder<M> &operator-=(const Remainder<M> &x){_v -= x._v; MOD(_v, M); return *this;}
	Remainder<M> &operator*=(Remainder<M> &x){ll tmp = (ll)_v * x._v; MOD(tmp, M); _v = tmp; return *this;}
	Remainder<M> &operator*=(const Remainder<M> &x){ll tmp = (ll)_v * x._v; MOD(tmp, M); _v = tmp; return *this;}
	Remainder<M> operator^(int n) const {return pow(_v, n);}
	Remainder<M> operator^(ll n) const {return pow(_v, n);}
	Remainder<M> inverseByFermat() const {return pow(_v, M - 2);}
	Remainder<M> inverseByExtgcd() const {return extgcd(M, _v).second;}
	Remainder<M> operator/(const Remainder<M> &x)const{return (*this) * x.inverseByExtgcd();}
	Remainder<M> &operator/=(Remainder<M> &x){ll tmp = (ll)_v * extgcd(M, _v).second; MOD(tmp, M); _v = tmp; return *this;}
	Remainder<M> &operator/=(const Remainder<M> &x){ll tmp = (ll)_v * extgcd(M, _v).second; MOD(tmp, M); _v = tmp; return *this;}
	int value() const {return _v;}
	bool operator==(const Remainder<M> &x) const {return _v == x._v;}
	bool operator!=(const Remainder<M> &x) const {return _v != x._v;}                                        
private:
	int _v;

	template<typename L>
	static int pow(int x, L n)
	{
		if(n == 0)
		{
			return 1 % M;
		}
		ll ans = pow(x, n >> 1);
		ans = ans * ans % M;
		if(n & 1)
		{
			ans = ans * x % M;
		}
		return ans;
	}
	static pair<ll, ll> extgcd(ll a, ll b)
	{
		if(a >= b){return extgcd0(a, b);}
		pair<ll, ll> xy = extgcd0(b, a);
		swap(xy.first, xy.second);
		return xy;				
	}
	static pair<ll, ll> extgcd0(ll a, ll b)
	{
		if(b == 0)
		{
			return {1, 0};
		}
		pair<ll, ll> xy = extgcd0(b, a % b);
		return {xy.second, xy.first - xy.second * (a / b)};
	}
};

template<int M>
inline ostream& operator<<(ostream &os, const Remainder<M> &x)
{
	return os << x.value();
}
template<int M>
inline istream& operator>>(istream &is, Remainder<M> &x)
{
	ll val;
	is >> val;
	x = val;
	return is;
}

#undef MOD

typedef Remainder<(int)1e9+7> rd;
   
vector< vector<int> > edges(5001);
vector<rd> comp(5001);
vector<int> sizes(5001);

void debug(int id, vector<rd[2]> &v)
{
	for(int i = 0; i <= sizes[id]; i++)
	{
		cerr << "dp[" << id << "][" << i << "][0]=" << v[i][0] << endl;
		cerr << "dp[" << id << "][" << i << "][1]=" << v[i][1] << endl;
	}
}

void DfsForSize(int root, int p)
{
	sizes[root] = 1;
	for(int node : edges[root])
	{
		if(node == p) continue;
		DfsForSize(node, root);
		sizes[root] += sizes[node];
	}                  
}

vector<rd[2]> dfs(int root, int p)
{
	vector<rd[2]> last_dp(sizes[root] + 1);
	vector<rd[2]> next_dp(sizes[root] + 1);
	last_dp[1][0] = 1;
	int total = 1;
	for(int node : edges[root])
	{
		if(node == p)
			continue;                          
		vector<rd[2]> node_dp = dfs(node, root);    
		for(int i = 0; i <= sizes[node] + total; i++)
		{
			next_dp[i][0] = next_dp[i][1] = 0;
		}
		for(int i = 1; i <= sizes[node]; i++)
		{
			for(int j = 1; j <= total; j++)
			{
				next_dp[j][0] += last_dp[j][0] * comp[i] * node_dp[i][1] +  last_dp[j][1] * comp[i] * node_dp[i][0];
				next_dp[j][1] += last_dp[j][1] * comp[i] * node_dp[i][1] +  last_dp[j][0] * comp[i] * node_dp[i][0];
				next_dp[j + i][0] += last_dp[j][0] * node_dp[i][0] + last_dp[j][1] * node_dp[i][1];
				next_dp[j + i][1] += last_dp[j][1] * node_dp[i][0] + last_dp[j][0] * node_dp[i][1];

			}
		}	
		total += sizes[node]; 
		for(int i = 0; i <= total; i++)
		{
			last_dp[i][0] = next_dp[i][0];
			last_dp[i][1] = next_dp[i][1];
		}
	}	                     
	//debug(root, last_dp);
	return last_dp;
} 

int main()
{
	ios_base::sync_with_stdio(false);
    cin.tie(NULL);
	cout << std::setiosflags(std::ios::fixed);
	cout << std::setprecision(15);

	int n;
	cin >> n;
	for(int i = 1; i < n; i++)
	{
		int a, b;
		cin >> a >> b;
		edges[a].pb(b);
		edges[b].pb(a);
	}

	comp[0] = 1;
	for(int i = 2; i <= n; i += 2)
	{
		comp[i] = comp[i - 2] * (i - 1);
	} 
	
	DfsForSize(1, 0);
	vector<rd[2]> dp = dfs(1, 0);


	rd ans = 0;
	for(int i = 1; i <= n; i++)
	{
		ans += (dp[i][0] - dp[i][1]) * comp[i];	
	}

	cout << ans;
    return 0;
}   




Measured memory_bytes: 131456