#[allow(unused_imports)]
use std::cmp::{min,max};
#[allow(unused_imports)]
use std::collections::{BTreeMap,BTreeSet};
#[allow(unused_imports)]
use std::ops::*;
#[allow(unused_imports)]
use std::collections::BinaryHeap;

#[allow(unused_macros)]
macro_rules! tf {
    ($c:expr, $t:expr, $f:expr) => {{
        if $c { $t } else { $f }
    }};
}

fn dfs(graph: &Vec<Vec<usize>>, gs: &Vec<Mod>, prev: Option<usize>, v: usize) -> Vec<Mod> {
    let mut xs = vec![Mod(0), Mod(1)];
    for &w in &graph[v] {
        if prev == Some(w) {
            continue;
        }
        let ys = dfs(graph, gs, Some(v), w);
        let mut zs = vec![Mod(0); xs.len() + ys.len() - 1];
        for (i,&x) in xs.iter().enumerate() {
            for (k,&y) in ys.iter().enumerate() {
                // 繋げる場合
                // 構築中の連結成分のサイズはi+k, 連結成分の数は変わらないので(+)
                zs[i+k] += Mod(1) * x * y;
                // 繋げない場合
                // 構築中の連結成分のサイズはi, サイズkの連結成分が増える，連結成分の数が1つ増えるので(-)
                zs[i] += -Mod(1) * x * y * gs[k];
            }
        }
        xs = zs;
    }
    xs
}

fn main() {
    let n = read_i64() as usize;
    let graph = {
        let mut graph = vec![vec![]; n];
        for _ in 0..n-1 {
            let (a,b) = {
                let xs = read_vec_i64();
                ((xs[0]-1) as usize, (xs[1]-1) as usize)
            };
            graph[a].push(b);
            graph[b].push(a);
        }
        graph
    };
    let gs = {
        let mut gs = vec![Mod(0); n+1];
        gs[2] = Mod(1);
        for i in 4..n+1 {
            if i % 2 == 0 {
                gs[i] = gs[i-2] * Mod((i-1) as u64);
            }
        }
        gs
    };
    let xs = dfs(&graph, &gs, None, 0);
    let mut res = Mod(0);
    for (i,&x) in xs.iter().enumerate() {
        // 構築中のサイズiの連結成分の分を乗算
        res += x * gs[i];
    }
    println!("{}", res.0);
}

const MOD : u64 = 1_000_000_007;
#[derive(Clone,Copy,PartialEq,Debug)]
struct Mod (u64);

impl Mod {
    fn pow(self, n: u64) -> Mod {
        if n == 0 {
            return Mod(1);
        }
        let t = self.pow(n/2);
        if n % 2 == 0 {
            t * t
        }
        else {
            t * t * self
        }
    }
}

impl Add for Mod {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Mod((self.0 + rhs.0) % MOD)
    }
}

impl AddAssign for Mod {
    fn add_assign(&mut self, rhs: Self) {
        *self = *self + rhs;
    }
}

impl Sub for Mod {
    type Output = Self;
    fn sub(self, rhs: Self) -> Self::Output {
        Mod((self.0 + MOD - rhs.0 % MOD) % MOD)
    }
}

impl SubAssign for Mod {
    fn sub_assign(&mut self, rhs: Self) {
        *self = *self - rhs;
    }
}

impl Neg for Mod {
    type Output = Mod;
    fn neg(self) -> Mod {
        Mod(MOD - self.0)
    }
}

impl Mul for Mod {
    type Output = Self;
    fn mul(self, rhs: Self) -> Self::Output {
        Mod(self.0 % MOD * rhs.0 % MOD)
    }
}

impl Div for Mod {
    type Output = Self;
    fn div(self, rhs: Self) -> Self::Output {
        self * rhs.pow(MOD-2)
    }
}

#[allow(dead_code)]
fn read_line() -> String {
    let mut ret = String::new();
    std::io::stdin().read_line(&mut ret).ok();
    ret.pop();
    //ret.pop();
    return ret;
}

#[allow(dead_code)]
fn read_i64() -> i64 {
    let ss = read_line();
    return ss.parse::<i64>().unwrap();
}

#[allow(dead_code)]
fn read_vec_i64() -> Vec<i64> {
    let mut res = vec![];
    let ss = read_line();
    for ts in ss.split_whitespace() {
        let x = ts.parse::<i64>().unwrap();
        res.push(x);
    }
    return res;
}

use std::fmt::Display;
#[allow(dead_code)]
fn write_vec<T: Display>(xs: &Vec<T>) {
    if xs.len() == 0 {
        println!("");
        return;
    }
    print!("{}", xs[0]);
    for i in 1..xs.len() {
        print!(" {}", xs[i]);
    }
    println!("");
}


Measured memory_bytes: 6652