Problem:
Score : 800 points

Problem Statement

12:17 (UTC): The sample input 1 and 2 were swapped. The error is now fixed. We are very sorry for your inconvenience.

There are N children in AtCoder Kindergarten, conveniently numbered 1 through N. Mr. Evi will distribute C indistinguishable candies to the children.

If child i is given a candies, the child's happiness will become x_i^a, where x_i is the child's excitement level. The activity level of the kindergarten is the product of the happiness of all the N children.

For each possible way to distribute C candies to the children by giving zero or more candies to each child, calculate the activity level of the kindergarten. Then, calculate the sum over all possible way to distribute C candies. This sum can be seen as a function of the children's excitement levels x_1,..,x_N, thus we call it f(x_1,..,x_N).

You are given integers A_i,B_i (1≦i≦N). Find modulo 10^9+7.

Constraints

1≦N≦400

1≦C≦400

1≦A_i≦B_i≦400 (1≦i≦N)

Partial Score

400 points will be awarded for passing the test set satisfying A_i=B_i (1≦i≦N).

Input

The input is given from Standard Input in the following format:

N C
A_1 A_2 ... A_N
B_1 B_2 ... B_N

Output

Print the value of modulo 10^9+7.

Sample Input 1

2 3
1 1
1 1

Sample Output 1

4

This case is included in the test set for the partial score, since A_i=B_i.
We only have to consider the sum of the activity level of the kindergarten where the excitement level of both child 1 and child 2 are 1 (f(1,1)).

If child 1 is given 0 candy, and child 2 is given 3 candies, the activity level of the kindergarten is 1^0*1^3=1.

If child 1 is given 1 candy, and child 2 is given 2 candies, the activity level of the kindergarten is 1^1*1^2=1.

If child 1 is given 2 candies, and child 2 is given 1 candy, the activity level of the kindergarten is 1^2*1^1=1.

If child 1 is given 3 candies, and child 2 is given 0 candy, the activity level of the kindergarten is 1^3*1^0=1.

Thus, f(1,1)=1+1+1+1=4, and the sum over all f is also 4.

Sample Input 2

1 2
1
3

Sample Output 2

14

Since there is only one child, child 1's happiness itself will be the activity level of the kindergarten. Since the only possible way to distribute 2 candies is to give both candies to child 1, the activity level in this case will become the value of f.

When the excitement level of child 1 is 1, f(1)=1^2=1.

When the excitement level of child 1 is 2, f(2)=2^2=4.

When the excitement level of child 1 is 3, f(3)=3^2=9.

Thus, the answer is 1+4+9=14.

Sample Input 3

2 3
1 1
2 2

Sample Output 3

66

Since it can be seen that f(1,1)=4 , f(1,2)=15 , f(2,1)=15 , f(2,2)=32, the answer is 4+15+15+32=66.

Sample Input 4

4 8
3 1 4 1
3 1 4 1

Sample Output 4

421749

This case is included in the test set for the partial score.

Sample Input 5

3 100
7 6 5
9 9 9

Sample Output 5

139123417

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::str::FromStr;
use std::io::*;
use std::cmp::*;
use utils::*;

#[cfg(not(feature = "local"))]
macro_rules! log { ($($e:expr),*) => {}; }

pub fn main() {
    let i = stdin();
    let mut o = Vec::new();
    run(i.lock(), &mut o);
    stdout().write_all(&o).unwrap();
}

fn run<R: BufRead, W: Write>(i: R, o: &mut W) {
    let mut i = AtRead::from(i);
    let (n, c) = i.read2::<usize, usize>();
    let a = i.read_vec::<usize>(n);
    let b = i.read_vec::<usize>(n);

    writeln!(o, "{}", solve(n, c, &a, &b)).unwrap();
}
fn solve(n: usize, c: usize, a: &[usize], b: &[usize]) -> usize {
    log!();
    let f = |x: &[usize]| {
        let mut t = vec![vec![ModNum(0); c + 1]; x.len() + 1];
        t[0][0] = ModNum(1);
        for i in 1..t.len() {
            let xi = x[i - 1];
            let mut xi_pow = ModNum(1);
            for j in 0..c + 1 {
                for k in j..c + 1 {
                    t[i][k] += t[i - 1][k - j] * xi_pow;
                }
                xi_pow *= xi;
            }
        }
        t[x.len()][c]
    };

    let mut x = vec![0; n];
    for i in 0..n {
        x[i] = a[i];
    }
    let mut sum = ModNum::new(0);
    loop {
        sum += f(&x);
        for i in 0.. {
            if i == x.len() {
                return sum.0;
            }
            if x[i] < b[i] {
                for j in 0..i {
                    x[j] = a[j]
                }
                x[i] += 1;
                break;
            }
        }
    }
}

mod utils {
    #![allow(dead_code)]
    use super::*;
    use std::ops::*;

    pub struct AtRead<R: BufRead> {
        r: R,
        s: String,
    }

    macro_rules! fn_read {
        {$f:ident($($v:ident: $t:ident),*)} => {
            pub fn $f<$($t: FromStr),*>(&mut self) -> ($($t),*) {
                let i = &mut self.read_line().split(' ');
                $(
                    let $v = next(i);
                )*
                ($($v),*)
            }
        };
    }

    impl<R: BufRead> AtRead<R> {
        pub fn from(r: R) -> Self {
            AtRead {
                r: r,
                s: String::new(),
            }
        }
        pub fn read_line(&mut self) -> &str {
            self.s.clear();
            self.r.read_line(&mut self.s).unwrap();
            self.s.trim()
        }

        pub fn read<T: FromStr>(&mut self) -> T {
            self.read_line().parse().ok().unwrap()
        }
        fn_read! { read2(v1: T1, v2: T2) }
        fn_read! { read3(v1: T1, v2: T2, v3: T3) }
        fn_read! { read4(v1: T1, v2: T2, v3: T3, v4: T4) }

        pub fn read_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
            self.read_line()
                .split(' ')
                .take(n)
                .map(|x| x.parse().ok().unwrap())
                .collect()
        }
    }

    fn next<'a, T: FromStr, I: std::iter::Iterator<Item = &'a str>>(i: &mut I) -> T {
        i.next().unwrap().parse().ok().unwrap()
    }

    const MOD_BASE: usize = 1000000007;
    const MOD_INV_POW: usize = 1000000005;

    #[derive(Debug, Clone, Copy)]
    pub struct ModNum(pub usize);

    impl ModNum {
        pub fn new(n: usize) -> Self {
            ModNum(n % MOD_BASE)
        }
        pub fn pow(self, mut exp: usize) -> ModNum {
            let mut b = self;
            let mut r = ModNum(1);
            while exp != 0 {
                if exp % 2 == 1 {
                    r *= b;
                }
                exp /= 2;
                b = b * b;
            }
            r
        }
        pub fn inverse_element(self) -> ModNum {
            self.pow(MOD_INV_POW)
        }
    }

    macro_rules! modnum_op {
        (($ot:ident, $f:ident), ($ot_a:ident, $f_a:ident), $($rhs:ty, $e:expr,)*) => {
            $(
            impl $ot<$rhs> for ModNum {
                type Output = Self;
                fn $f(self, rhs: $rhs) -> Self {
                    Self::new(($e)(self, rhs))
                }
            }
            impl $ot_a<$rhs> for ModNum {
                fn $f_a(&mut self, rhs: $rhs) {
                    *self = Self::new(($e)(*self, rhs))
                }
            }
            )*
        }
    }

    modnum_op!(
        (Add, add),
        (AddAssign, add_assign),
        ModNum,
        |l: ModNum, r: ModNum| l.0 + r.0,
        usize,
        |l: ModNum, r: usize| l.0 + r,
    );

    modnum_op!(
        (Mul, mul),
        (MulAssign, mul_assign),
        ModNum,
        |l: ModNum, r: ModNum| l.0 * r.0,
        usize,
        |l: ModNum, r: usize| l.0 * r,
    );

    modnum_op!(
        (Sub, sub),
        (SubAssign, sub_assign),
        ModNum,
        |l: ModNum, r: ModNum| MOD_BASE + l.0 - r.0,
        usize,
        |l: ModNum, r: usize| MOD_BASE + l.0 - r,
    );

}