#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet, BinaryHeap, VecDeque, BTreeSet, BTreeMap};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[allow(unused_imports)]
use std::io::stdin;
mod util {
use std::io::stdin;
use std::str::FromStr;
use std::fmt::Debug;
#[allow(dead_code)]
pub fn line() -> String {
let mut line: String = String::new();
stdin().read_line(&mut line).unwrap();
line.trim().to_string()
}
#[allow(dead_code)]
pub fn gets<T: FromStr>() -> Vec<T>
where
<T as FromStr>::Err: Debug,
{
let mut line: String = String::new();
stdin().read_line(&mut line).unwrap();
line.split_whitespace()
.map(|t| t.parse().unwrap())
.collect()
}
}
#[allow(unused_macros)]
macro_rules! get {
($t:ty) => {
{
let mut line: String = String::new();
stdin().read_line(&mut line).unwrap();
line.trim().parse::<$t>().unwrap()
}
};
($($t:ty),*) => {
{
let mut line: String = String::new();
stdin().read_line(&mut line).unwrap();
let mut iter = line.split_whitespace();
(
$(iter.next().unwrap().parse::<$t>().unwrap(),)*
)
}
};
($t:ty; $n:expr) => {
(0..$n).map(|_|
get!($t)
).collect::<Vec<_>>()
};
($($t:ty),*; $n:expr) => {
(0..$n).map(|_|
get!($($t),*)
).collect::<Vec<_>>()
};
($t:ty ;;) => {
{
let mut line: String = String::new();
stdin().read_line(&mut line).unwrap();
line.split_whitespace()
.map(|t| t.parse::<$t>().unwrap())
.collect::<Vec<_>>()
}
};
}
#[allow(unused_macros)]
macro_rules! debug {
($($a:expr),*) => {
println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
}
}
fn gcd(a: u64, b: u64) -> u64 {
if b == 0 { a } else { gcd(b, a % b) }
}
fn lcm(a: u64, b: u64) -> u64 {
a / gcd(a, b) * b
}
// (gcd, x, y)
fn extgcd(a: i64, b: i64) -> (i64, i64, i64) {
if b == 0 {
(a, 1, 0)
} else {
let (gcd, x, y) = extgcd(b, a % b);
(gcd, y, x - (a / b) * y)
}
}
fn mod_pow(x: u64, n: u64, m: u64) -> u64 {
let mut res = 1;
let mut x = x;
let mut n = n;
while n > 0 {
if n & 1 == 1 {
res = (res * x) % m;
}
x = (x * x) % m;
n = n >> 1;
}
res
}
fn mod_inverse(a: u64, m: u64) -> u64 {
let (_, x, _) = extgcd(a as i64, m as i64);
((m as i64 + x) as u64 % m) % m
}
fn fact_table(len: usize, m: u64) -> Vec<u64> {
let mut res = vec![1; len];
for i in 1..len {
res[i] = (i as u64 * res[i - 1]) % m;
}
res
}
// (a mod p, e when n! = a p^e)
fn mod_fact(n: u64, p: u64, fact: &Vec<u64>) -> (u64, u64) {
if n == 0 {
(1, 0)
} else {
let (a, b) = mod_fact(n / p, p, fact);
let e = b + n / p;
if n / p % 2 != 0 {
(a * (p - fact[(n % p) as usize]) % p, e)
} else {
(a * fact[(n % p) as usize] % p, e)
}
}
}
fn mod_comb(n: u64, k: u64, p: u64, fact: &Vec<u64>) -> u64 {
if n < k {
0
} else {
let (a1, e1) = mod_fact(n, p, fact);
let (a2, e2) = mod_fact(k, p, fact);
let (a3, e3) = mod_fact(n - k, p, fact);
if e1 > e2 + e3 {
0
} else {
a1 * mod_inverse(a2 * a3 % p, p) % p
}
}
}
const M: u64 = 1000000007;
fn main() {
let (n, a, b, c, d) = get!(usize, usize, usize, usize, usize);
let fact = fact_table(n + 1, M);
let mut dp = vec![0; n + 1];
dp[n] = 1;
for i in a..b + 1 {
let mut next = dp.clone();
if i * c > n {
break;
}
for k in i * c..n + 1 {
let mut m = c;
while k >= m * i && m <= d && (k - m * i >= (i + 1) * c || k % i == 0) {
if dp[k] > 0 && (k - m * i >= (i + 1) * c || k - m * i == 0) {
// let mut delta = mod_comb(k as u64, (m * i) as u64, M, &fact) * fact[m * i] % M;
let mut delta = fact[k] * mod_inverse(fact[k - m * i], M) % M;
delta = delta * mod_inverse(mod_pow(fact[i], m as u64, M), M) % M;
delta = delta * mod_inverse(fact[m], M) % M;
next[k - m * i] += delta * dp[k] % M;
next[k - m * i] %= M;
}
m += 1;
}
}
dp = next;
}
println!("{}", dp[0]);
}