// Original C++ solution (slower):
#include <cstdio>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

#define N 5005

#define M 10005

#define ll long long

#define mod 1000000007

void Read(int &p)

{

	p = 0;

	char c = getchar();

	for (; c < '0' || c > '9'; c = getchar());

	for (; c >= '0' && c <= '9'; c = getchar())p = p * 10 + c - '0';

}

int n, tar[M], nex[M], fir[N], cnt;

int siz[N];

int dp[N][N], f[N], g[N];

void Add(int a, int b)

{

	++cnt;

	tar[cnt] = b;

	nex[cnt] = fir[a];

	fir[a] = cnt;

}

void Dfs(int r, int fa)

{

	siz[r] = 1;

	dp[r][1] = 1;

	for (int i = fir[r]; i; i = nex[i])

	{

		int v = tar[i];

		if (v != fa)

		{

			Dfs(v, r);

		    for (int j = 0; j <= siz[r]; j++)

			{

				g[j] = dp[r][j];

				dp[r][j] = 0;

			}

			for (int j = 0; j <= siz[r]; j++)

				for (int k = 0; k <= siz[v]; k++)

					dp[r][j + k] = (dp[r][j + k] + (ll)g[j] * dp[v][k]) % mod;

			siz[r] += siz[v];

		}

	}

	for (int i = 0; i <= siz[r]; i++)

		dp[r][0] = (dp[r][0] - (ll)dp[r][i] * f[i]) % mod;

}

int main()

{

	Read(n);

	for (int i = 1; i < n; i++)

	{

		int u, v;

		Read(u), Read(v);

		Add(u, v), Add(v, u);

	}

	f[0] = 1;

	for (int i = 1; i <= n; i++)

	{

		if (i & 1)continue;

		f[i] = (ll)f[i - 2] * (i - 1) % mod;

	}

	Dfs(1, 0);

	int ans = -dp[1][0];

	if (ans < 0)

		ans += mod;

	printf("%d\n", ans);

}

///


// Optimized solution to the same problem (faster):
#include <cstdio>



const int mod = 1e9 + 7;

const int MAXN = 5005;



template<typename _T>

void read( _T &x )

{

	x = 0;char s = getchar();int f = 1;

	while( s > '9' || s < '0' ){if( s == '-' ) f = -1; s = getchar();}

	while( s >= '0' && s <= '9' ){x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar();}

	x *= f;

}



template<typename _T>

void write( _T x )

{

	if( x < 0 ){ putchar( '-' ); x = ( ~ x ) + 1; }

	if( 9 < x ){ write( x / 10 ); }

	putchar( x % 10 + '0' );

}



struct edge

{

	int to, nxt;

}Graph[MAXN << 1];



int tmp[MAXN];

int f[MAXN][MAXN], g[MAXN];

int head[MAXN], siz[MAXN];

int N, cnt;



void sub( int &x, const int v ) { x = ( x < v ? x + mod - v : x - v ); }

void add( int &x, const int v ) { x = ( x + v >= mod ? x + v - mod : x + v ); }



void addEdge( const int from, const int to )

{

	Graph[++ cnt].to = to, Graph[cnt].nxt = head[from];

	head[from] = cnt;

}



void DFS( const int u, const int fa )

{

	f[u][1] = 1, siz[u] = 1;

	for( int i = head[u], v ; i ; i = Graph[i].nxt )

		if( ( v = Graph[i].to ) ^ fa )

		{

			DFS( v, u );

			for( int i = 0 ; i <= siz[u] + siz[v] ; i ++ ) tmp[i] = 0; 

			for( int j = siz[u] ; j ; j -- )

				for( int k = siz[v] ; ~ k ; k -- )

					add( tmp[j + k], 1ll * f[u][j] * f[v][k] % mod );

			siz[u] += siz[v];

			for( int i = 0 ; i <= siz[u] ; i ++ ) f[u][i] = tmp[i];

		}

	for( int i = 1 ; i <= siz[u] ; i ++ )

		sub( f[u][0], 1ll * f[u][i] * g[i] % mod );

}



int main()

{

	read( N );

	for( int i = 1, a, b ; i < N ; i ++ )

		read( a ), read( b ), addEdge( a, b ), addEdge( b, a );

	g[2] = 1;

	for( int i = 4 ; i <= N ; i += 2 )

		g[i] = 1ll * g[i - 2] * ( i - 1 ) % mod;

	DFS( 1, 0 );

	write( ( mod - f[1][0] ) % mod ), putchar( '\n' );

	return 0;

}

// Fastest known solution for this problem: