use std::cmp::min;
use core::ops::Bound::Excluded;
use core::ops::Bound::Included;
use std::collections::BTreeSet;
use std::cmp::Ordering;
use std::fmt::Debug;

fn read_line() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("No Line");
    buffer
}
fn read_lines<R, T: Fn(&str)->R> (count: usize, transformer: T) -> Vec<R> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(transformer(buffer.trim()));
        buffer.clear();
    }
    vec
}
fn read_value<T: std::str::FromStr>() -> T {
    read_line().trim().parse().ok().unwrap()
}
fn read_values<T: std::str::FromStr>() -> Vec<T> {
    read_line().trim().split(' ').map(|x| x.parse().ok().expect("Can't Parse")).collect::<Vec<T>>()
}
fn read_tabulate<T: std::str::FromStr>(count: usize) -> Vec<T> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(buffer.trim().parse().ok().expect("Can't Parse"));
        buffer.clear();
    }
    vec
}
macro_rules! define {
    () => {};
    ($($token:tt)*) => {
        let mut iter = read_values::<String>().into_iter();
        define_iter!(iter, $($token)*);
    };
}
macro_rules! define_iter {
    ($iter:expr) =>{};
    ($iter:expr,) =>{};
    ($iter:expr, $id:ident:$t:tt $($tail:tt)*) => {
        let $id: $t = $iter.next().unwrap().parse().ok().expect("Can't Parse");
        define_iter!($iter, $($tail)*);
    };
    ($iter:expr, mut $id:ident:$t:tt $($tail:tt)*) => {
        let mut $id: $t = $iter.next().unwrap().parse().ok().expect("Can't Parse");
        define_iter!($iter, $($tail)*)
    };
}
macro_rules! freeze {
    ($($id:ident), *) => {
        $(let $id = $id;)*
    };
}
struct KeyValue<K, V> {
    key: K,
    value: V
}
impl <K: PartialOrd, V> PartialEq for KeyValue<K, V> {
    fn eq(&self, other: &Self) -> bool {
        self.key.eq(&other.key)
    }
}
impl <K: PartialOrd, V> Eq for KeyValue<K, V> {}
impl <K: PartialOrd, V> PartialOrd for KeyValue<K, V> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.key.partial_cmp(&other.key)
    }
}
impl <K: PartialOrd, V> Ord for KeyValue<K, V> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.key.partial_cmp(&other.key).ok_or("Can't Compare").unwrap()
    }
}
const MOD: i64 = 1000000007;
fn power(base: i64, exp: usize) -> i64 {
    match exp {
        0 => 1i64,
        1 => base % MOD,
        _ => power(base * base % MOD, exp >> 1) * power(base, exp & 1) % MOD
    }
}
fn main() {
    define! {
        n: usize
        a: usize
        b: usize
        c: usize
        d: usize
    }
    let mut factorial = vec![1; n + 1];
    let mut div = vec![1; n + 1];
    let mut inverse = vec![1i64; n + 1];
    for i in 2 ..= n {
        factorial[i] = i as i64 * factorial[i - 1] % MOD;
        div[i] = (MOD - MOD / i as i64) * div[(MOD % i as i64) as usize] % MOD;
        inverse[i] = div[i] * inverse[i - 1] % MOD;
    }
    freeze!(factorial, inverse);
    let permutation = |n: usize, r: usize | factorial[n] * inverse[n - r] % MOD;
    let mut dp = vec![vec![0i64; n + 1]; n + 1];
    for i in 0 .. n {dp[i][0] = 1;}
    for i in a ..= b {
        for j in 0 ..= n {
            dp[i][j] = dp[i - 1][j];
        }
        for j in c ..= d {
            if i * j > n {break;};
            for k in i * j ..= n {
                dp[i][k] += dp[i - 1][k - i * j] * permutation(n - k + i * j, i * j) % MOD * power(inverse[i], j) % MOD * inverse[j] % MOD;
            }
        }
        for j in 0 ..= n {
            dp[i][j] %= MOD;
        }
    }
    println!("{}", dp[b][n]);
}


Measured memory_bytes: 9976