We have a sequence A of N non-negative integers.
Compute the sum of \prod _{i = 1} ^N \dbinom{B_i}{A_i} over all sequences B of N non-negative integers whose sum is at most M, and print it modulo (10^9 + 7).
Here, \dbinom{B_i}{A_i}, the binomial coefficient, denotes the number of ways to choose A_i objects from B_i objects, and is 0 when B_i < A_i.

-----Constraints-----
 - All values in input are integers.
 - 1 \leq N \leq 2000
 - 1 \leq M \leq 10^9
 - 0 \leq A_i \leq 2000

-----Input-----
Input is given from Standard Input in the following format:
N M
A_1 A_2 \ldots A_N

-----Output-----
Print the sum of \prod _{i = 1} ^N \dbinom{B_i}{A_i}, modulo (10^9 + 7).

-----Sample Input-----
3 5
1 2 1

-----Sample Output-----
8

There are four sequences B such that \prod _{i = 1} ^N \dbinom{B_i}{A_i} is at least 1:
 - B = \{1, 2, 1\}, where \prod _{i = 1} ^N \dbinom{B_i}{A_i} = \dbinom{1}{1} \times \dbinom{2}{2} \times \dbinom{1}{1} = 1;
 - B = \{2, 2, 1\}, where \prod _{i = 1} ^N \dbinom{B_i}{A_i} = \dbinom{2}{1} \times \dbinom{2}{2} \times \dbinom{1}{1} = 2;
 - B = \{1, 3, 1\}, where \prod _{i = 1} ^N \dbinom{B_i}{A_i} = \dbinom{1}{1} \times \dbinom{3}{2} \times \dbinom{1}{1} = 3;
 - B = \{1, 2, 2\}, where \prod _{i = 1} ^N \dbinom{B_i}{A_i} = \dbinom{1}{1} \times \dbinom{2}{2} \times \dbinom{2}{1} = 2.
The sum of these is 1 + 2 + 3 + 2 = 8.

Difficulty: competition

Starter code:

Solutions:
from functools import reduce

def modpow(a, n, m):
    if n == 0:
        return 1
    tmp = modpow(a, n // 2, m)
    if n % 2 == 0:
        return tmp * tmp % m
    else:
        return tmp * tmp * a % m

def modinv(a, m):
    return modpow(a, m - 2, m)

n, m = [int(_) for _ in input().split(' ')]
s = sum([int(_) for _ in input().split(' ')])

M = 1_000_000_007
product = lambda x1, x2: x1 * x2 % M

print((reduce(product, list(range(m - s + 1, m + n + 1))) * modinv(reduce(product, list(range(1, s + n + 1))), M) % M))


n,m,*a=map(int,open(0).read().split())
d=10**9+7
l=1
r=1
for i in range(n+sum(a)):
    l,r=l*(n+m-i)%d,r*(i+1)%d
print(l*pow(r,d-2,d)%d)

def mod_combination(n, k, mod = 10 ** 9 + 7):
    def extended_gcd(a, b):
        if b == 0:
            return (a, 1, 0)
        d, x, y = extended_gcd(b, a % b)
        return (d, y, x - (a // b) * y)
    p, q = 1, 1
    for i in range(n - k + 1, n + 1):
        p = (p * i) % mod
    for i in range(2, k + 1):
        q = (q * i) % mod
    return p * (extended_gcd(q, mod)[1] % mod) % mod


N, M, *A = map(int, open(0).read().split())

S = sum(A)
print(mod_combination(M + N, S + N))

n,m = map(int,input().split())
a = list(map(int,input().split()))
mod = 10**9+7

s = sum(a)
fact = 1
ans = 1
for i in range(s+n):
    ans *= (m+n-i)
    ans %=mod
    fact *= (i+1)
    fact %= mod
    
ans *= pow(fact,mod-2,mod)
print(ans%mod)

import itertools
N, M, *A = [int(_) for _ in open(0).read().split()]


class Factorial:
    def __init__(self, max_fact, mod):
        #mod should be prime number
        #using homogeneous_product(n,r), max_fact ≧ max(n+r-1)
        f = [1] * (max_fact + 1)
        for idx in range(2, max_fact + 1):
            f[idx] = f[idx - 1] * idx
            f[idx] %= mod
        if mod > max_fact:
            fi = [pow(f[-1], mod - 2, mod)]
            for idx in range(max_fact, 0, -1):
                fi += [fi[-1] * idx % mod]
            fi = fi[::-1]
        else:
            fi = [pow(n, mod - 2, mod) for n in f]
        self.mod = mod
        self.f = f
        self.fi = fi

    def factorial(self, n):
        return self.f[n]

    def factorial_inverse(self, n):
        return self.fi[n]

    def combination(self, n, r):
        if n < r:
            return 0
        elif n < 2 * r:
            r = n - r
        f = self.f
        fi = self.fi
        mod = self.mod
        if n < len(f):
            return f[n] * fi[r] * fi[n - r] % mod
        if r < len(f):
            ret = fi[r]
            for _ in range(r):
                ret *= n
                ret %= mod
                n -= 1
            return ret
        else:
            1 / 0

    def permutation(self, n, r):
        f = self.f
        fi = self.fi
        mod = self.mod
        if n < len(f):
            return f[n] * fi[n - r] % mod
        elif r < len(f):
            ret = 1
            for _ in range(r):
                ret *= n
                ret %= mod
                n -= 1
            return ret
        else:
            1 / 0

    def homogeneous_product(self, n, r):
        f = self.f
        fi = self.fi
        return f[n + r - 1] * fi[r] * fi[n - 1] % self.mod


suma = sum(A)
max_fact = suma + N
mod = 10**9 + 7
fact_instance = Factorial(max_fact, mod)
comb = fact_instance.combination

ans = comb(M + N, N + suma)
print(ans)
'''
ans = 0
for bs in itertools.product(range(M + 1), repeat=N):
    f = 0
    if sum(bs) > M:
        continue
    ans += list(
        itertools.accumulate([comb(b, a) for a, b in zip(A, bs)],
                             func=lambda x, y: x * y % mod))[-1]
    ans %= mod
print(ans)
'''
'''
ans(N, M, sum(A))

ans(3, 1, 1) = C[4, 0]
ans(3, 2, 2) = C[5, 0]
ans(3, 3, 3) = C[6, 0]

ans(3, 4, 4) = C[7, 0]

ans(3, 6, 5) = C[9, 1]
ans(4, 6, 5) = C[10, 1]

ans(N, M, sum(A)) = C[N + M, M - sum(A)]
'''


import sys
input = sys.stdin.readline

N,M=list(map(int,input().split()))
A=list(map(int,input().split()))

mod=10**9+7

SUM=sum(A)
r=M-SUM
S=r+SUM+N

F=1
for i in range(1,S-r+1):
    F=F*i%mod


if M<SUM:
    print((0))
else:
    ANS=1
    y=1
    for i in range(S-r):
        ANS=ANS*S%mod
        S-=1
    ANS=ANS*pow(F,mod-2,mod)%mod


    print(ANS)

        
    


import sys
input = sys.stdin.readline
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, accumulate
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right

SI = lambda: input()
NI = lambda:int(input())
MI = lambda:map(int, input().split())
cutLF = lambda x:list(x)[:-1] if x[-1]=='\n' else list(x)
strLST = lambda:cutLF(input())

n,m=MI()
*a,=MI()
s=sum(a)
mod=10**9+7
hidari=[]
start=n+m
for i in range(n+s):
    hidari.append(start-i)
    
left=1
right=1
for i in range(n+s):
    left*=hidari[i]
    left%=mod
    right*=(i+1)
    right%=mod

print(left*pow(right,mod-2,mod)%mod)

import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def modInverse(a, p):
    return pow(a, p - 2, p)


def modBinomial(n, k, p):
    k = min(k, n - k)
    numerator = 1
    for i in range(k):
        numerator = (numerator * (n - i)) % p

    denominator = 1
    for i in range(1, k + 1):
        denominator = (denominator * i) % p

    return (numerator * modInverse(denominator, p)) % p


def main():
    N, M = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]

    MOD = 10 ** 9 + 7

    if sum(A) > M:
        print((0))
        return

    r = sum(A) + N

    print((modBinomial(M + N, r, MOD)))


def __starting_point():
    main()

__starting_point()

P = 10 ** 9 + 7
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
s = sum(A)
u = 1
v = 1
for i in range(M - s + 1, N + M + 1):
    u = u * i % P
for i in range(1, s + N + 1):
    v = i * v % P
print(u * pow(v, P - 2, P) % P)

n, m = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a)
mod = 10 ** 9 + 7
ans, cnt = 1, 1
for i in range(n + m, m - s, -1):
    ans *= i
    ans %= mod
for i in range(1, s + n + 1):
    cnt *= i
    cnt %= mod
print(ans * pow(cnt, mod - 2, mod) % mod)

k = 72
kk = k // 4
K = 1<<k
nu = lambda L: int("".join([hex(K+a)[3:] for a in L[::-1]]), 16)
st = lambda n: hex(n)[2:]
li = lambda s, l, r: [int(a, 16) % P if len(a) else 0 for a in [s[-(i+1)*kk:-i*kk] for i in range(l, r)]]

def grow(d, v, h, start):
    h += [0] * d
    f = [(-1 if (i+d) % 2 else 1) * fainv[i] * fainv[d-i] % P * h[i] % P for i in range(d+1)]
    nuf = nu(f)
    a = d * inv[v] % P
    t = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        t[i] = t[i-1] * (a - d + i - 1) % P
    ti = [1] * (3*d+3)
    ti[-1] = pow(t[-1], P-2, P)
    for i in range(1, 3*d+3)[::-1]:
        ti[i-1] = ti[i] * (a - d + i - 1) % P
    iv = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        iv[i] = ti[i] * t[i-1] % P
 
    ###
    # g = [iv[i] for i in range(1, 2*d+2)]
    g = iv[1:2*d+2]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d+1):
        h[i] = h[i] * (fg[i] * t[d+i+1] % P * ti[i] % P) % P
 
    ###
    # g = [inv[i] for i in range(1, 2*d+2)]
    g = inv[1:2*d+2]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = fg[i] * fa[d+i+1] % P * fainv[i] % P
 
    ###
    # g = [iv[i] for i in range(d+2, 3*d+3)]
    g = iv[d+2:3*d+3]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = h[i+d+1] * (fg[i] * t[2*d+i+2] % P * ti[d+i+1] % P) % P
 
    return h

# Create a table of the factorial of the first v+2 multiples of v, i.e., [0!, v!, 2v!, ..., (v(v+1))!]
def create_table(v, start):
    s = 1
    X = [start, v + start]
    while s < v:
        X = grow(s, v, X, start)
        s *= 2
 
    table = [1]
    for x in X:
        table.append(table[-1] * x % P)
    return table

def fact(i, table):
    a = table[i//v]
    for j in range(i//v*v+1, i+1):
        a = a * j % P
    return a

P = 10 ** 9 + 7
nn = 4000000
v = 1 << (nn.bit_length() + 1) // 2
fa = [1] * (2*v+2)
fainv = [1] * (2*v+2)
for i in range(2*v+1):
    fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(2*v+1)[::-1]:
    fainv[i] = fainv[i+1] * (i+1) % P
inv = [0] * (2*v+2)
for i in range(1, 2*v+2):
    inv[i] = fainv[i] * fa[i-1] % P

def prod(a, b, v): # a * (a + 1) * ... * (b - 1)
    T = create_table(v, a)
    c = b - a
    s = T[c//v]
    if c > 10:
        vv = 1 << (c.bit_length() + 1) // 2
        return s * prod(c // v * v + a, b, vv) % P
    for i in range(c // v * v + a, b):
        s = s * i % P
    return s

def C(a, b):
    if b * 2 > a: b = a - b
    return prod(a - b + 1, a + 1, v) * pow(prod(1, b + 1, v), P - 2, P) % P

if 1:
    N, M = list(map(int, input().split()))
    A = [int(a) for a in input().split()]
    s = sum(A)
    print((C(N + M, s + N) if M >= s else 0))


# print(prod(1, nn, v))


import bisect
import functools
import heapq
import itertools
import sys
import math
import random
import time
from collections import Counter, deque, defaultdict
from functools import reduce
from operator import xor, itemgetter
from pprint import pprint
from types import FunctionType
from typing import List, Any
from sys import stdin

mod = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 9)

def inp(): return stdin.readline().rstrip()
def lmi(): return list(map(int, stdin.readline().split()))
def narray(*shape, init: Any = 0):
    if shape: return [narray(*shape[1:], init=init) for _ in range(shape[0])]
    if callable(init): return init()
    return init


def comb(N, k):
    if (k > N) or (N < 0) or (k < 0):
        return 0
    N, k = list(map(int, (N, k)))
    top = N
    val = 1
    while top > (N - k):
        val *= top
        top -= 1
    n = 1
    while n < k + 1:
        val //= n
        n += 1
    return val

def cmb(x, y):
    if x < y:
        return 0
    bunsi = 1
    bunbo = 1
    for i in range(1, y+1):
        bunsi = (bunsi*(x+1-i)) % mod
        bunbo = (bunbo*i) % mod
    res = bunsi*pow(bunbo,mod-2,mod) % mod
    return res

def main():
    N, M = lmi()
    A = lmi()
    ans = cmb((M + N) % mod, (N + sum(A)) % mod) % mod
    print(ans)




def __starting_point():
    main()


__starting_point()

def binomial_coefficient(n, r, mod=10**9+7):
    if r < 0 or r > n:
        return 0
    res = 1
    div = 1
    r = min(r, n - r)
    for i in range(r):
        res = res * (n - i) % mod
        div = div * (i + 1) % mod
    return res * pow(div, mod-2, mod) % mod


mod = 10 ** 9 + 7
n, m = map(int, input().split())
A = list(map(int, input().split()))
ans = binomial_coefficient(n + m, sum(A) + n, mod)
print(ans)

#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate

sys.setrecursionlimit(10**6)
INF = 10**12
p = 10**9 + 7


def main():
    N, M = list(map(int, input().split()))
    A = list(map(int, input().split()))
    S = sum(A)
    if M < S:
        print((0))
        return
    # 答えは(M+N)C(S+N)=(M+N)C(M-S)
    ans = 1
    div = 1
    for i in range(N+S):
        ans *= M + N - i
        div *= N + S - i
        ans %= p
        div %= p
        # print(ans, div)
    print((ans*pow(div, p-2, p) % p))


def __starting_point():
    main()

__starting_point()

import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N, M = mapint()
As = list(mapint())
mod = 10**9 + 7

SUM = sum(As)
ans = 1
for i in range(M-SUM+1, M+N+1):
    ans *= i
    ans %= mod

inv = 1
for i in range(1, SUM+N+1):
    inv *= i
    inv %= mod

print(ans*pow(inv, mod-2, mod)%mod)

# 考察:
#  1,一見するとDPの問題。
#    DP[m][i] = (B_1~B_iの総和がmとなるとき、i番目までを掛け算したものの和) とすればよさそう。
#    しかし、Mの制約が大きい。上のDPはO(MN)かかるため、確実にTLEする。
#  2,いろいろ考えたが、やはりMの制約が大きすぎる。もっと簡単な計算式があるのではないか。
#  3,数え上げの問題として捉える。
#    (B_i A_i)は、しきりをA_i個、ボールをK_i = (B_i-A_i)個並べる場合の数である。
#    掛け算しているため、しきりA_i個、ボールK_i個のセクション(1~N)が独立して置かれているとみなせる。
#    例：N = 3, A = [1,2,3], K = B-A = [6,5,3]のとき
#     o o o | o o o (セクション1)
#     o o | o | o o (セクション2)
#     o | | o | o (セクション3)
#    さらにB_iも可変。拘束条件は、今あるしきりとボールの合計がM個以下であることのみ。
#    セクション1~Nを横並べにして、セクション間にさらにしきりを導入する。
#    さらに最後のセクションの後にしきりを設ける。
#    しきりとボールの合計がM個に満たない場合、この仕切りの後にその分のボールを置く。
#    例：N = 3, A = [1,2,3], K = B-A = [6,5,3], M = 22(2個あまる)のとき
#     o o o | o o o x o o | o | o o x o | | o | o x o o  (セクション間のしきりを「x」とした)
#    ここで、2種類のしきりを区別する必要がない。
#    (A_iが決まっているため、どの仕切りがどちらの意味のしきりであるかは一意に復元できる。)
#  結論：しきりN+ΣA個、ボールM-ΣA個を並べる場合の数を求めればよい。

N, M = map(int,input().split())
A = list(map(int,input().split()))
mod = 10**9 + 7

invs = [0,1]

X = N + M # しきりとボールの数の和
Y = N + sum(A) # しきりの数

def inv(x):
  if x == 1: return 1
  else: return  (-invs[mod % x] * (mod // x)) % mod
for i in range(2,Y+1): #事前に逆元計算
  invs.append(inv(i))
  
ans = 1
for i in range(Y): #(X Y)の計算
  ans *= (X-i) * invs[i+1]
  ans %= mod
print(ans % mod)

import sys


class IO:
    @staticmethod
    def get(type=str):
        return type(input().strip())
    
    @staticmethod
    def gets(type=str):
        return [type(x) for x in input().split()]


def printerr(*args, **kw):
    print(*args, **kw, file=sys.stderr)


def inv(n, p):
    return pow(n, p-2, p)

def comb(n, k, p):
    k = min(k, n-k)
    t, d = 1, 1
    for i in range(k):
        t *= n - i
        t %= P
        d *= i+1
        d %= P
    return t * inv(d, P) % P


P = 10 ** 9 + 7

def main():
    n, m = IO.gets(int)
    a = IO.gets(int)

    x = sum(a) + n
    dm = m - sum(a)
    printerr(f"x={x} dm={dm}")

    if dm < 0:
        ans = 0
    elif dm == 0:
        ans = 1
    else:
        # ans = (1 - pow(x, m+1, P)) * inv(1 - x, P) % P
        ans = comb(x+dm, dm, P)

    print(ans)


def __starting_point():
    main()
__starting_point()

k = 72
kk = k // 4
K = 1<<k
def nu(L, sl = -1):
    if sl == -1: sl = slice(0,len(L))
    return int("".join([hex(K+a)[3:] for a in L[sl][::-1]]), 16)
st = lambda n: hex(n)[2:]
li = lambda s, l, r: [int(a, 16) % P if len(a) else 0 for a in [s[-(i+1)*kk:-i*kk] for i in range(l, r)]]

def grow(d, v, h, start):
    h += [0] * d
    f = [(-1 if (i+d) % 2 else 1) * fainv[i] * fainv[d-i] % P * h[i] % P for i in range(d+1)]
    nuf = nu(f)
    a = d * inv[v] % P
    t = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        t[i] = t[i-1] * (a - d + i - 1) % P
    ti = [1] * (3*d+3)
    ti[-1] = pow(t[-1], P-2, P)
    for i in range(1, 3*d+3)[::-1]:
        ti[i-1] = ti[i] * (a - d + i - 1) % P
    iv = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        iv[i] = ti[i] * t[i-1] % P
    ###
    fg = li(st(nuf * nu(iv[1:2*d+2])), d, d * 2 + 1)
    for i, (_fg, _ti) in enumerate(zip(fg, ti)):
        h[i] = h[i] * (_fg * t[d+i+1] % P * _ti % P) % P
    ###
    fg1 = li(st(nuf * nu(inv[1:2*d+2])), d, d * 2 + 1)
    fg2 = li(st(nuf * nu(iv[d+2:3*d+3])), d, d * 2 + 1)
    fg1.pop()
    for i, (_fg1, _fg2) in enumerate(zip(fg1, fg2)):
        h[i+d+1] = _fg1 * _fg2 % P * fa[d+i+1] % P * fainv[i] % P * t[2*d+i+2] % P * ti[d+i+1] % P
    return h

def create_table(v, start = 1):
    s = 1
    X = [start, v + start]
    while s < v:
        X = grow(s, v, X, start)
        s *= 2
    table = [1]
    for x in X:
        table.append(table[-1] * x % P)
    return table

P = 10 ** 9 + 7
nn = 4000000
v = 1 << (nn.bit_length() + 1) // 2
fa = [1] * (2*v+2)
fainv = [1] * (2*v+2)
for i in range(2*v+1):
    fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(2*v+1)[::-1]:
    fainv[i] = fainv[i+1] * (i+1) % P
inv = [0] * (2*v+2)
for i in range(1, 2*v+2):
    inv[i] = fainv[i] * fa[i-1] % P

def prod(a, b, vv): # a * (a + 1) * ... * (b - 1) % P
    T = create_table(vv, a)
    c = b - a
    s = T[c//vv]
    for i in range(c // vv * vv + a, b):
        s = s * i % P
    return s

def C(a, b):
    if not 0 <= b <= a: return 0
    if b * 2 > a: b = a - b
    return prod(a - b + 1, a + 1, v) * pow(prod(1, b + 1, v), P - 2, P) % P

N, M = map(int, input().split())
s = sum([int(a) for a in input().split()])
print(C(N + M, s + N))

import sys

def solve():
    input = sys.stdin.readline
    N, M = map(int, input().split())
    A = [int(a) for a in input().split()]
    if M < sum(A):
        print(0)
        return 0
    mod = 7 + 10 ** 9
    
    Ans = 1
    sumA = sum(A)
    for i in range(sumA + N):
        Ans *= (M + N - i)
        Ans %= mod
    fact = 1
    for i in range(1, sumA + N + 1):
        fact *= i
        fact %= mod
    Ans *= pow(fact, mod - 2, mod)
    print(Ans % mod)    
    
    return 0

def __starting_point():
    solve()
__starting_point()

M=lambda:map(int,input().split())
n,m=M()
a=sum(list(M()))
d=10**9+7
l=1
r=1
for i in range(n+a):
    l,r=l*(n+m-i)%d,r*(i+1)%d
print(l*pow(r,d-2,d)%d)

import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def LS2(): return list(sys.stdin.readline().rstrip())


N,M = MI()
A = LI()
s = sum(A)
mod = 10**9+7

if s > M:
    print((0))
    return

# (M+N)_C_(s+N)

a = 1
for i in range(1,s+N+1):
    a *= i
    a %= mod

ans = pow(a,mod-2,mod)
for i in range(s+N):
    ans *= M+N-i
    ans %= mod

print(ans)


from functools import reduce

def combination2(n, r, MOD=10**9+7):
    if not 0 <= r <= n: return 0
    r = min(r, n - r)
    numerator = reduce(lambda x, y: x * y % MOD, range(n, n - r, -1), 1)
    denominator = reduce(lambda x, y: x * y % MOD, range(1, r + 1), 1)
    return numerator * pow(denominator, MOD - 2, MOD) % MOD

N,M=map(int, input().split())
A=list(map(int, input().split()))
S=sum(A)
print(combination2(M+N,S+N))

import sys
def input(): return sys.stdin.readline().rstrip()

def permutation(n, r, mod=10**9+7):  # 順列数
    permutation = 1
    for i in range(r):
        permutation = permutation*(n-i) % mod
    return permutation

def combination(n, r, mod=10**9+7):  # 組み合わせ数
    r = min(n-r, r)
    bunshi = permutation(n, r, mod)
    bunbo = 1
    for i in range(1, r+1):
        bunbo = bunbo*i % mod
    return bunshi*pow(bunbo, mod-2, mod) % mod


def main():
    mod = 10**9+7
    mod2 = 998244353
    n, m = map(int, input().split())
    A = list(map(int, input().split()))
    ans = 1
    for AA in A:
        ans *= AA
        ans %= mod
    sumA = sum(A)
    if sumA > m:
        print(0)
    else:
        nokori = m-sum(A)
        print(combination(m+n, sumA+n, mod=10**9+7))


def __starting_point():
    main()
__starting_point()

import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def modInverse(a, p):
    return pow(a, p - 2, p)


def modBinomial(n, k, p):
    k = min(k, n - k)
    numerator = 1
    for i in range(k):
        numerator = (numerator * (n - i)) % p

    denominator = 1
    for i in range(1, k + 1):
        denominator = (denominator * i) % p

    return (numerator * modInverse(denominator, p)) % p


def main():
    N, M = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]

    MOD = 10 ** 9 + 7

    if sum(A) > M:
        print((0))
        return

    x = sum(A) + N + 1
    sa = (M - sum(A))

    nn = (x - 1 + sa)
    rr = sa

    print((modBinomial(nn, rr, MOD)))


def __starting_point():
    main()

__starting_point()

def comb(n, r, mod):
    x, y = 1, 1
    for i in range(n, n - r, -1):
        x *= i
        y *= i + r - n
        x %= mod
        y %= mod
    return pow(y, mod - 2, mod) * x % mod

n, m = map(int, input().split())
a = list(map(int, input().split()))
mod = pow(10, 9) + 7
ans = comb(n + m, n + sum(a), mod)
print(ans)

import sys
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians

sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7

def lcm(x,y):
    return x*y//gcd(x,y)
def lgcd(l):
    return reduce(gcd,l)
def llcm(l):
    return reduce(lcm,l)
def powmod(n,i,mod=MOD):
    return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
    return x.bit_length()
def div10(x):
    return len(str(x))-(x==0)
def intput():
    return int(input())
def mint():
    return map(int,input().split())
def lint():
    return list(map(int,input().split()))
def ilint():
    return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
    print(l[0] if x else l[1])
def lprint(l, sep='\n'):
    for x in l:
        print(x, end=sep)
def ston(c, c0='a'):
    return ord(c)-ord(c0)
def ntos(x, c0='a'):
    return chr(x+ord(c0))
class counter(dict):
    def __init__(self, *args):
        super().__init__(args)
    def add(self,x,d=1):
        self.setdefault(x,0)
        self[x] += d
    def list(self):
        l = []
        for k in self:
            l.extend([k]*self[k])
        return l
class comb():
    def __init__(self, n, mod=None):
        self.l = [1]
        self.n = n
        self.mod = mod
    def get(self,k):
        l,n,mod = self.l, self.n, self.mod
        if k<0 or n<k:
            return 0
        k = n-k if k>n//2 else k
        while len(l)<=k:
            i = len(l)
            l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
        return l[k]
def pf(x,mode='counter'):
    C = counter()
    p = 2
    while x>1:
        k = 0
        while x%p==0:
            x //= p
            k += 1
        if k>0:
            C.add(p,k)
        p = p+2-(p==2) if p*p<x else x
    if mode=='counter':
        return C
    S = set([1])
    for k in C:
        T = deepcopy(S)
        for x in T:
            for i in range(1,C[k]+1):
                S.add(x*(k**i))
    if mode=='set':
        return S
    if mode=='list':
        return sorted(list(S))

######################################################

def cmb(n, r, mod):
    if ( r<0 or r>n ):
        return 0
    r = min(r, n-r)
    return g1[n] * g2[r] * g2[n-r] % mod

mod = 10**9+7 #出力の制限
N = 10**4
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル

for i in range( 2, N + 1 ):
    g1.append( ( g1[-1] * i ) % mod )
    inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
    g2.append( (g2[-1] * inverse[-1]) % mod )

N,M=mint()
A=lint()
S=sum(A)
if S>M:
    print(0)
    return
    
n = S+N+M-S
k = S+N
mod = 10**9 + 7

# def modinv(x):
# xの逆元を求める際に[mod % x]の逆元が必要なので、関数の形でxの逆元を直接求めることは難しい。再帰を使えば行けそうだけど。

modinv_table = [-1] * (k+1)
modinv_table[1] = 1
for i in range(2, k+1):
    modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod

def binomial_coefficients(n, k):
    ans = 1
    for i in range(k):
        ans *= n-i
        ans *= modinv_table[i + 1]
        ans %= mod
    return ans

print(binomial_coefficients(n, k))

N, M = map(int, input().split())
A = list(map(int, input().split()))
S = sum(A)
MOD = 10**9+7
def comb(n,r):
  ans = div = 1
  for i in range(r):
    ans = ans * (n-i) % MOD
    div = div * (i+1) % MOD
  ans = ans * pow(div, MOD-2, MOD) % MOD
  return ans
ans = comb(N+M, S+N)
print(ans)

n,m=map(int,input().split())
a=list(map(int,input().split()))
mod=10**9+7
inv=[0,1]
for i in range(2,5*10**6):
  inv+=[inv[mod%i]*(mod-int(mod/i))%mod]
s=sum(a)
ans=1
for i in range(n+s):
  ans*=(n+m-i)
  ans%=mod
  ans*=inv[i+1]
  ans%=mod
print(ans)

k = 72
kk = k // 4
K = 1<<k
nu = lambda L: int("".join([hex(K+a)[3:] for a in L[::-1]]), 16)
st = lambda n: hex(n)[2:]
li = lambda s, l, r: [int(a, 16) % P if len(a) else 0 for a in [s[-(i+1)*kk:-i*kk] for i in range(l, r)]]

def grow(d, v, h, start):
    h += [0] * d
    f = [(-1 if (i+d) % 2 else 1) * fainv[i] * fainv[d-i] % P * h[i] % P for i in range(d+1)]
    nuf = nu(f)
    a = d * inv[v] % P
    t = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        t[i] = t[i-1] * (a - d + i - 1) % P
    ti = [1] * (3*d+3)
    ti[-1] = pow(t[-1], P-2, P)
    for i in range(1, 3*d+3)[::-1]:
        ti[i-1] = ti[i] * (a - d + i - 1) % P
    iv = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        iv[i] = ti[i] * t[i-1] % P
 
    ###
    g = [inv[i] for i in range(1, 2*d+2)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = fg[i] * fa[d+i+1] % P * fainv[i] % P
 
    ###
    g = [iv[i] for i in range(1, 2*d+2)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d+1):
        h[i] = h[i] * (fg[i] * t[d+i+1] % P * ti[i] % P) % P
 
    ###
    g = [iv[i] for i in range(d+2, 3*d+3)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = h[i+d+1] * (fg[i] * t[2*d+i+2] % P * ti[d+i+1] % P) % P
 
    return h

# Create a table of the factorial of the first v+2 multiples of v, i.e., [0!, v!, 2v!, ..., (v(v+1))!]
def create_table(v, start):
    s = 1
    X = [start, v + start]
    while s < v:
        X = grow(s, v, X, start)
        s *= 2
 
    table = [1]
    for x in X:
        table.append(table[-1] * x % P)
    return table

def fact(i, table):
    a = table[i//v]
    for j in range(i//v*v+1, i+1):
        a = a * j % P
    return a

P = 10**9+7
nn = 2020000
v = 1 << (nn.bit_length() + 1) // 2
fa = [1] * (2*v+2)
fainv = [1] * (2*v+2)
for i in range(2*v+1):
    fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(2*v+1)[::-1]:
    fainv[i] = fainv[i+1] * (i+1) % P
inv = [0] * (2*v+2)
for i in range(1, 2*v+2):
    inv[i] = fainv[i] * fa[i-1] % P

def prod(a, b): # a * (a + 1) * ... * (b - 1)
    T = create_table(v, a)
    c = b - a
    s = T[c//v]
    for i in range(c // v * v + a, b):
        s = s * i % P
    return s

def C(a, b):
    if b * 2 > a: b = a - b
    return prod(a - b + 1, a + 1) * pow(prod(1, b + 1), P - 2, P) % P

P = 10 ** 9 + 7
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
s = sum(A)
print(C(N + M, s + N) if M >= s else 0)

N,M = map(int, input().split())
A = list(map(int, input().split()))
mod = 10**9 + 7

def binomial_coefficients(n, k):
    numera = 1  # 分子
    denomi = 1  # 分母

    for i in range(k):
        numera *= n-i
        numera %= mod
        denomi *= i+1
        denomi %= mod
    
    return numera * pow(denomi,-1,mod) % mod

print(binomial_coefficients(M+N,N+sum(A)))

n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9+7

s = sum(A)
ans = 1

def comb(n, r, mod):
    c = 1
    for i in range(r):
        c *= n-i
        c %= mod

    d = 1
    for i in range(1, r+1):
        d *= i
        d %= mod

    return (c * pow(d, mod-2, mod)) % mod


print((comb(m+n, s+n, mod)))



N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
S = sum(A)
MOD = 10**9 + 7

a = b = 1
for i in range(1, S+N+1):
    a *= M + N  + 1 - i
    a %= MOD
    b *= i
    b %= MOD

ans = a * pow(b, MOD-2, MOD)
ans %= MOD
print(ans)


MOD = 10 ** 9 + 7
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
r = n + sum(a)
m += n
if m < r:
    print((0))
else:
    ans = 1
    v = 1
    for i in range(r):
        v *= i + 1
        ans *= (m - i)
        v %= MOD
        ans %= MOD
    print((ans * pow(v, MOD - 2, MOD) % MOD))


class Factorials:
    def __init__(self, n=10**6, mod=10**9+7):
        self.mod = mod

        # self.fac[i] ≡ i! (factorial:階乗)
        self.fac = [1] * (n+1)
        for i in range(2, n+1):
            self.fac[i] = self.fac[i-1] * i % mod

        """
        # self.rec[i] ≡ 1 / i! (reciprocal:逆数)
        self.rec = [1] * (n+1)
        self.rec[n] = pow(self.fac[n], mod-2, mod)
        for i in range(n-1, 1, -1):
            self.rec[i] = self.rec[i+1] * (i+1) % mod

    # self.comb(n, r) ≡ nCr
    def comb(self, n, r):
        return self.fac[n] * self.rec[r] * self.rec[n-r] % self.mod
    
    # self.perm(n, r) ≡ nPr
    def perm(self, n, r):
        return self.fac[n] * self.rec[n-r] % self.mod

    # self.inv(n) ≡ 1 / n ≡ pow(n, mod-2, mod)
    def inv(self, n):
        return self.fac[n-1] * self.rec[n] % self.mod
    """

mod = 10**9 + 7

def fact(n, r):
    res = 1
    for i in range(r):
        res *= n - i
        res %= mod
    return res

n, m = map(int, input().split())
a = list(map(int, input().split()))

sum_a = sum(a)
if m < sum_a:
    print(0)
    return

fct = Factorials(sum_a + n)

print(fact(n+m, sum_a+n) * pow(fct.fac[sum_a+n], mod-2, mod) % mod)

def comb(n, r, mod):
    x, y = 1, 1
    for i in range(n, n - r, -1):
        x *= i
        y *= i + r - n
        x %= mod
        y %= mod
    return pow(y, -1, mod) * x % mod

n, m = map(int, input().split())
a = list(map(int, input().split()))
mod = pow(10, 9) + 7
ans = comb(n + m, n + sum(a), mod)
print(ans)

mod = 10**9+7
n, m = map(int, input().split())
s = sum(map(int, input().split()))
a = n+m
b = s+n
num = 1
den = 1
for i in range(b):
  num *= a-i
  num %= mod
  den *= i+1
  den %= mod
ans = num * pow(den, mod-2, mod) % mod
print(ans)

import sys
input = sys.stdin.readline
N, M = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
mod = 10 ** 9 + 7
dsm = M - sum(a)
if dsm < 0:
  print(0)
  return

class Factorial:
  def __init__(self, n, mod):
    self.mod = mod
    self.f = [1]
    for i in range(1, n + 1):
      self.f.append(self.f[-1] * i % mod)
    self.i = [pow(self.f[-1], mod - 2, mod)]
    for i in range(1, n + 1)[: : -1]:
      self.i.append(self.i[-1] * i % mod)
    self.i.reverse()
  def factorial(self, i): return self.f[i]
  def ifactorial(self, i): return self.i[i]
  def combi(self, n, k): return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod
  def permi(self, n, k): return self.f[n] * self.i[n - k] % self.mod

sm = sum(a)
res = Factorial(sm + N, mod).ifactorial(sm + N)
for x in range(N + M, N + M - sm - N, -1):
  res *= x
  res %= mod
print(res)

N, M = map(int, input().split())
s = sum(list(map(int, input().split())))

p = 10 ** 9 + 7

fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]

for i in range(2, s + N + 1):
    fact.append((fact[-1] * i) % p)
    inv.append((-inv[p % i] * (p // i)) % p)
    factinv.append((factinv[-1] * inv[-1]) % p)

ans = factinv[s + N]

for i in range(s + N):
    ans *= M + N - i
    ans %= p

print(ans)

from numba import njit
N, M, *A = [int(_) for _ in open(0).read().split()]
mod = 10**9 + 7
suma = sum(A)
x = M + N
y = N + suma
a = 1
b = 1


@njit('i8(i8,i8,i8)')
def pow_mod(base, exp, mod):
    exp %= mod - 1
    res = 1
    while exp:
        if exp & 1:
            res = res * base % mod
        base = base * base % mod
        exp >>= 1
    return res


@njit('i8(i8,i8)')
def comb(x, y):
    a = b = 1
    for _ in range(y):
        a *= x
        b *= y
        a %= mod
        b %= mod
        x -= 1
        y -= 1
    ret = a * pow_mod(b, mod - 2, mod) % mod
    return ret


print((comb(M + N, N + suma)))


import sys
# import numpy as np
# from numba import njit, i8, void

MOD = 10**9 + 7

N, M = list(map(int, sys.stdin.readline().rstrip().split()))
# A = np.array([int(x) for x in sys.stdin.readline().rstrip().split()], dtype=np.int64)
A = [int(x) for x in sys.stdin.readline().rstrip().split()]


# @njit(void(i8, i8, i8[:]), cache=True)
def solve(N, M, A):

    S = sum(A)

    num = 1
    don = 1

    for i in range(1, S + N + 1):
        num = num * (M + N - (i - 1)) % MOD
        don = don * i % MOD

    ans = num * pow(don, MOD - 2, MOD) % MOD

    # print(INV)

    print(ans)


solve(N, M, A)


MOD = 10**9+7
n, m = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a)
ans = 1
den = 1
for i in range(s+n):
	ans *= m + n - i
	ans %= MOD
	den *= i+1
	den %= MOD

ans = (ans * pow(den, MOD-2, MOD)) % MOD
print(ans)

def nCr(n,r):
    A=B=1
    for _ in range(r):
        A*=n
        A%=Mod

        B*=r
        B%=Mod

        n-=1
        r-=1

    return (A*pow(B,Mod-2,Mod))%Mod

N,M=map(int,input().split())
A=list(map(int,input().split()))
Mod=10**9+7
print(nCr(M+N,sum(A)+N))

MOD=10**9+7

def COM(n,r):
    P,Q=1,1
    for i in range(r):
        P=P*(n-i)%MOD
        Q=Q*(r-i)%MOD
    return P*pow(Q,MOD-2,MOD)%MOD

N,M=map(int,input().split())
S=sum(list(map(int,input().split())))

print(COM(N+M,S+N))

def cmb(x, y):
    if x < y:
        return 0
    bunsi = 1
    bunbo = 1
    for i in range(1, y+1):
        bunsi = (bunsi*(x+1-i)) % mod
        bunbo = (bunbo*i) % mod
    res = bunsi*pow(bunbo,mod-2,mod) % mod
    return res

n,m = map(int,input().split())
a = list(map(int,input().split()))
mod = 10**9+7

s = sum(a)
ans = cmb(m+n,s+n)
print(ans)

n,m = list(map(int,input().split()))
A = list(map(int,input().split()))
mod = 10**9+7
s = sum(A)
if s>m:print((0));return
ans = 1
a = 1
for i in range(n+s):
    ans*=m+n-i
    a*=i+1
    ans%=mod
    a%=mod

ans = ans*pow(a,mod-2,mod)
print((ans%mod))


import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def modInverse(a, p):
    return pow(a, p - 2, p)


def modBinomial(n, k, p):
    numerator = 1
    for i in range(k):
        numerator = (numerator * (n - i)) % p

    denominator = 1
    for i in range(1, k + 1):
        denominator = (denominator * i) % p

    return (numerator * modInverse(denominator, p)) % p


def main():
    N, M = [int(x) for x in input().split()]
    A = [int(x) for x in input().split()]

    MOD = 10 ** 9 + 7

    if sum(A) > M:
        print((0))
        return

    x = sum(A) + N + 1
    sa = (M - sum(A))

    nn = (x - 1 + sa)
    rr = sa

    print((modBinomial(nn, min(rr, nn - rr), MOD)))


def __starting_point():
    main()

__starting_point()

def solve():
    mod = 10**9 + 7
    N, M = map(int,input().split())
    A = list(map(int,input().split()))
    M += N
    S = sum(A) + N
    if S > M:
        print(0)
        return
    ans = 1
    d = 1
    for i in range(1,S+1):
        ans = (ans*(M+1-i)) % mod 
        d = (d * i) % mod
    ans = (ans * pow(d,mod-2,mod)) % mod
    """
    for i in range(1,S+1):
        ans = (ans*(M+1-i)) % mod
        d = pow(i,mod-2,mod)
        ans = (ans*d) % mod
    """
    print(ans)


def __starting_point():
    solve()
__starting_point()

k = 72
kk = k // 4
K = 1<<k
nu = lambda L: int("".join([hex(K+a)[3:] for a in L[::-1]]), 16)
st = lambda n: hex(n)[2:]
li = lambda s, l, r: [int(a, 16) % P if len(a) else 0 for a in [s[-(i+1)*kk:-i*kk] for i in range(l, r)]]

def grow(d, v, h, start):
    h += [0] * d
    f = [(-1 if (i+d) % 2 else 1) * fainv[i] * fainv[d-i] % P * h[i] % P for i in range(d+1)]
    nuf = nu(f)
    a = d * inv[v] % P
    t = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        t[i] = t[i-1] * (a - d + i - 1) % P
    ti = [1] * (3*d+3)
    ti[-1] = pow(t[-1], P-2, P)
    for i in range(1, 3*d+3)[::-1]:
        ti[i-1] = ti[i] * (a - d + i - 1) % P
    iv = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        iv[i] = ti[i] * t[i-1] % P
 
    ###
    g = [inv[i] for i in range(1, 2*d+2)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = fg[i] * fa[d+i+1] % P * fainv[i] % P
 
    ###
    g = [iv[i] for i in range(1, 2*d+2)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d+1):
        h[i] = h[i] * (fg[i] * t[d+i+1] % P * ti[i] % P) % P
 
    ###
    g = [iv[i] for i in range(d+2, 3*d+3)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = h[i+d+1] * (fg[i] * t[2*d+i+2] % P * ti[d+i+1] % P) % P
 
    return h

# Create a table of the factorial of the first v+2 multiples of v, i.e., [0!, v!, 2v!, ..., (v(v+1))!]
def create_table(v, start):
    s = 1
    X = [start, v + start]
    while s < v:
        X = grow(s, v, X, start)
        s *= 2
 
    table = [1]
    for x in X:
        table.append(table[-1] * x % P)
    return table

def fact(i, table):
    a = table[i//v]
    for j in range(i//v*v+1, i+1):
        a = a * j % P
    return a

P = 10**9+7
nn = 2020000
v = 1 << (nn.bit_length() + 1) // 2
fa = [1] * (2*v+2)
fainv = [1] * (2*v+2)
for i in range(2*v+1):
    fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(2*v+1)[::-1]:
    fainv[i] = fainv[i+1] * (i+1) % P
inv = [0] * (2*v+2)
for i in range(1, 2*v+2):
    inv[i] = fainv[i] * fa[i-1] % P

def prod(a, b): # a * (a + 1) * ... * (b - 1)
    T = create_table(v, a)
    c = b - a
    s = T[c//v]
    for i in range(c // v * v + a, b):
        s = s * i % P
    return s

def C(a, b):
    if b * 2 > a: b = a - b
    return prod(a - b + 1, a + 1) * pow(prod(1, b + 1), P - 2, P) % P

P = 10 ** 9 + 7
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
s = sum(A)
print(C(N + M, s + N) if M >= s else 0)

N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
X,Y = M+N, sum(A)+N
p = 10**9+7
def nCr(n, r, mod=p):
  a,b = 1,1
  for i in range(r):
    a *= n-i
    a %= mod
    b *= i+1
    b %= mod
  return (a*pow(b,mod-2,mod))%mod
print((nCr(X,Y,p)))


P = 10 ** 9 + 7
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
u = 1
v = 1
for i in range(sum(A) + N):
    u = u * (N + M - i) % P
    v = (i + 1) * v % P
print(u * pow(v, P - 2, P) % P)

#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n, m = LI()
a = LI()
s = sum(a)
if m + n < s + n:
    print(0)
else:
    ans = 1
    inv = 1
    for i in range(s+n):
        ans *= m + n - i
        ans %= mod
        inv *= i+1
        inv %= mod
    print(ans * pow(inv, mod-2, mod) % mod)

import sys
def input():return sys.stdin.readline()[:-1]
def N(): return int(input())
def NM():return map(int,input().split())
def L():return list(NM())

n,m=NM()
a=L()
mod=10**9+7
def comb(n,r):
    b=1
    a=1
    for i in range(r):
        b*=n-i
        a*=i+1
        b%=mod
        a%=mod
    return b*pow(a,mod-2,mod)%mod
print(comb(m+n,n+sum(a)))

N,M = map(int,input().split())
A = list(map(int,input().split()))
sa = sum(A)
MOD = 10**9+7
if sa > M:
    print(0)
    return
if sa == M:
    print(1)
    return

x = 1 + sa + N
n = M-sa

bunsi = bunbo = 1
for i in range(max(x,n+1), x+n):
    bunsi *= i
    bunsi %= MOD

for i in range(1,min(x,n+1)):
    bunbo *= i
    bunbo %= MOD

ans = bunsi * pow(bunbo, MOD-2, MOD)
ans %= MOD
print(ans)

def main():
    mod=1000000007
    n,m=map(int,input().split())
    A=list(map(int,input().split()))
    s=sum(A)
    if s>m:
        return 0
    ans=1
    inv=1
    for i in range(s+n):
        ans*=m+n-i
        inv*=i+1
        ans%=mod
        inv%=mod
    return ans*pow(inv,mod-2,mod)%mod
    
def __starting_point():
    print(main())
__starting_point()

import sys
# import numpy as np
# from numba import njit, i8, void

MOD = 10**9 + 7

N, M = list(map(int, sys.stdin.readline().rstrip().split()))
# A = np.array([int(x) for x in sys.stdin.readline().rstrip().split()], dtype=np.int64)
A = [int(x) for x in sys.stdin.readline().rstrip().split()]


# @njit(void(i8, i8, i8[:]), cache=True)
def solve(N, M, A):

    S = sum(A)

    num = 1
    don = 1

    for i in range(1, S + N + 1):
        num = num * (M + N - (i - 1)) % MOD
        don = don * i % MOD

    ans = num * pow(don, MOD - 2, MOD) % MOD

    # print(INV)

    print(ans)


solve(N, M, A)


k = 72
kk = k // 4
K = 1<<k
nu = lambda L: int("".join([hex(K+a)[3:] for a in L[::-1]]), 16)
st = lambda n: hex(n)[2:]
li = lambda s, l, r: [int(a, 16) % P if len(a) else 0 for a in [s[-(i+1)*kk:-i*kk] for i in range(l, r)]]

def grow(d, v, h, start):
    h += [0] * d
    f = [(-1 if (i+d) % 2 else 1) * fainv[i] * fainv[d-i] % P * h[i] % P for i in range(d+1)]
    nuf = nu(f)
    a = d * inv[v] % P
    t = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        t[i] = t[i-1] * (a - d + i - 1) % P
    ti = [1] * (3*d+3)
    ti[-1] = pow(t[-1], P-2, P)
    for i in range(1, 3*d+3)[::-1]:
        ti[i-1] = ti[i] * (a - d + i - 1) % P
    iv = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        iv[i] = ti[i] * t[i-1] % P
 
    ###
    g = [inv[i] for i in range(1, 2*d+2)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = fg[i] * fa[d+i+1] % P * fainv[i] % P
 
    ###
    g = [iv[i] for i in range(1, 2*d+2)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d+1):
        h[i] = h[i] * (fg[i] * t[d+i+1] % P * ti[i] % P) % P
 
    ###
    g = [iv[i] for i in range(d+2, 3*d+3)]
    fg = li(st(nuf * nu(g)), d, d * 2 + 1)
    for i in range(d):
        h[i+d+1] = h[i+d+1] * (fg[i] * t[2*d+i+2] % P * ti[d+i+1] % P) % P
 
    return h

# Create a table of the factorial of the first v+2 multiples of v, i.e., [0!, v!, 2v!, ..., (v(v+1))!]
def create_table(v, start):
    s = 1
    X = [start, v + start]
    while s < v:
        X = grow(s, v, X, start)
        s *= 2
 
    table = [1]
    for x in X:
        table.append(table[-1] * x % P)
    return table

def fact(i, table):
    a = table[i//v]
    for j in range(i//v*v+1, i+1):
        a = a * j % P
    return a

P = 10**9+7
nn = 3000000
v = 1 << (nn.bit_length() + 1) // 2
fa = [1] * (2*v+2)
fainv = [1] * (2*v+2)
for i in range(2*v+1):
    fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(2*v+1)[::-1]:
    fainv[i] = fainv[i+1] * (i+1) % P
inv = [0] * (2*v+2)
for i in range(1, 2*v+2):
    inv[i] = fainv[i] * fa[i-1] % P

def prod(a, b): # a * (a + 1) * ... * (b - 1)
    T = create_table(v, a)
    c = b - a
    s = T[c//v]
    for i in range(c // v * v + a, b):
        s = s * i % P
    return s

def C(a, b):
    if b * 2 > a: b = a - b
    return prod(a - b + 1, a + 1) * pow(prod(1, b + 1), P - 2, P) % P

P = 10 ** 9 + 7
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
s = sum(A)
print(C(N + M, s + N) if M >= s else 0)

def solve(n, m, aaa):
    s = sum(aaa)
    if s > m:
        return 0

    ms = m - s
    MOD = 10 ** 9 + 7

    f = 1
    for i in range(2, n + s + 1):
        f = f * i % MOD
    ans = pow(f, MOD - 2, MOD)

    for x in range(m + n, ms, -1):
        ans = ans * x % MOD

    return ans


n, m = list(map(int, input().split()))
aaa = list(map(int, input().split()))
print((solve(n, m, aaa)))


# 場合の数をmodで割った余り nCr % mod
def ncr_mod(n,r,mod):
  a,b=1,1
  for i in range(r):
    a*=n-i
    a%=mod
    b*=i+1
    b%=mod
  return (a*pow(b,mod-2,mod))%mod
n,m=map(int,input().split())
a=list(map(int,input().split()))
mod=10**9+7
ans=ncr_mod(m+n,sum(a)+n,mod)
print(ans)

N,M=list(map(int,input().split()))
A=[int(i) for i in input().split()]
sumA=sum(A)
mod=10**9+7
def inv(x):
    return pow(x,mod-2,mod)
ans=1
F=1
for i in range(N+sumA):
    ans*=(N+M-i)
    ans%=mod
    F*=(i+1)
    F%=mod
ans*=inv(F)
ans%=mod
print(ans)


N,M = map(int, input().split())
A = list(map(int, input().split()))
mod = 10**9 + 7

def binomial_coefficients(n, k):
    numera = 1  # 分子
    denomi = 1  # 分母

    for i in range(k):
        numera *= n-i
        numera %= mod
        denomi *= i+1
        denomi %= mod
    return numera * pow(denomi, mod-2, mod) % mod

print(binomial_coefficients(M+N,N+sum(A)))

import itertools
N, M, *A = [int(_) for _ in open(0).read().split()]


class Factorial:
    def __init__(self, max_fact, mod):
        #mod should be prime number
        #using homogeneous_product(n,r), max_fact ≧ max(n+r-1)
        f = [1] * (max_fact + 1)
        for idx in range(2, max_fact + 1):
            f[idx] = f[idx - 1] * idx
            f[idx] %= mod
        if mod > max_fact:
            fi = [pow(f[-1], mod - 2, mod)]
            for idx in range(max_fact, 0, -1):
                fi += [fi[-1] * idx % mod]
            fi = fi[::-1]
        else:
            fi = [pow(n, mod - 2, mod) for n in f]
        self.mod = mod
        self.f = f
        self.fi = fi

    def factorial(self, n):
        return self.f[n]

    def factorial_inverse(self, n):
        return self.fi[n]

    def combination(self, n, r):
        f = self.f
        fi = self.fi
        mod = self.mod
        if n < r:
            return 0
        elif n < len(f):
            return f[n] * fi[r] * fi[n - r] % mod
        elif n < 2 * r:
            r = n - r
        if r < len(f):
            ret = fi[r]
            for _ in range(r):
                ret *= n
                ret %= mod
                n -= 1
            return ret
        else:
            1 / 0

    def permutation(self, n, r):
        f = self.f
        fi = self.fi
        mod = self.mod
        if n < len(f):
            return f[n] * fi[n - r] % mod
        elif r < len(f):
            ret = 1
            for _ in range(r):
                ret *= n
                ret %= mod
                n -= 1
            return ret
        else:
            1 / 0

    def homogeneous_product(self, n, r):
        f = self.f
        fi = self.fi
        return f[n + r - 1] * fi[r] * fi[n - 1] % self.mod


suma = sum(A)
max_fact = suma + N
mod = 10**9 + 7
fact_instance = Factorial(max_fact, mod)
comb = fact_instance.combination

ans = comb(M + N, suma + N)
print(ans)
'''
ans = 0
for bs in itertools.product(range(M + 1), repeat=N):
    f = 0
    if sum(bs) > M:
        continue
    ans += list(
        itertools.accumulate([comb(b, a) for a, b in zip(A, bs)],
                             func=lambda x, y: x * y % mod))[-1]
    ans %= mod
print(ans)
'''
'''
ans(N, M, sum(A))

ans(3, 1, 1) = C[4, 0]
ans(3, 2, 2) = C[5, 0]
ans(3, 3, 3) = C[6, 0]

ans(3, 4, 4) = C[7, 0]

ans(3, 6, 5) = C[9, 1]
ans(4, 6, 5) = C[10, 1]

ans(N, M, sum(A)) = C[N + M, M - sum(A)]
'''


mod = 10 ** 9 + 7

def comb(n, m):
    ans = 1
    a, b = 1, 1
    for i in range(1, m + 1):
        a = a * (n - i + 1) % mod
        b = b * i % mod
        ans %= mod
    return a * pow(b, mod - 2, mod) % mod

N, M = map(int, input().split())
S = sum(map(int, input().split()))
print(comb(M + N, S + N))

N,M = map(int,input().split())
A = list(map(int,input().split()))
mod = 10**9+7
S = sum(A)

def cmb(a,b,mod):
    if a < b:
        return 0
    b = min(b,a-b)
    num = 1
    for i in range(b):
        num = num*(a-i) % mod
    den = 1
    for i in range(1,b+1):
        den = den*i % mod
    return num * pow(den,mod-2,mod) % mod

print(cmb(M+N,S+N,mod))

n,m=map(int, input().split())
*a,=map(int, input().split())
mod=10**9+7
l,r=1,1
for i in range(n+sum(a)):
    l,r=l*(n+m-i)%mod,r*(i+1)%mod
print(l*pow(r,mod-2,mod)%mod)

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter


import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline

INF = 1 << 60


def read_int():
    return int(readline())


def read_int_n():
    return list(map(int, readline().split()))


def read_float():
    return float(readline())


def read_float_n():
    return list(map(float, readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def ep(*args):
    print(*args, file=sys.stderr)


def epp(o):
    import pprint
    pprint.pprint(o, stream=sys.stderr)

def gen_2d_array(n, m, fill=0):
    if callable(fill):
        return [[fill()] * m for _ in range(n)]
    else:
        return [[fill] * m for _ in range(n)]


def gen_3d_array(n, m, k, fill=0):
    if callable(fill):
        return [[[fill()] * k for _ in range(m)] for _ in range(n)]
    else:
        return [[[fill] * k for _ in range(m)] for _ in range(n)]


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.perf_counter()
        ret = f(*args, **kwargs)
        e = time.perf_counter()

        ep(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, A):
    mod = 10**9 + 7
    S = sum(A)
    a = 1
    b = 1
    for i in range(1, N+S+1):
        a *= i
        a %= mod
        b *= M+N-i+1
        b %= mod

    return b * pow(a, mod-2, mod) % mod



def main():
    N, M = read_int_n()
    A = read_int_n()
    print(slv(N, M, A))


def __starting_point():
    main()

__starting_point()

# Date [ 2020-12-05 22:15:25 ]
# Problem [ d.py ]
# Author Koki_tkg

import sys

def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return list(map(int, sys.stdin.readline().strip().split()))
def read_str_split(): return list(sys.stdin.readline().strip())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))

def nCr(n, r, MOD):
    a, b = 1, 1
    for i in range(r):
        a = a * (n - i) % MOD
        b = b * (i + 1) % MOD
    return a * pow(b, MOD - 2, MOD) % MOD

def Main():
    N, M = read_ints()
    A = read_int_list()
    print((nCr(N + M, N + sum(A), 10**9 + 7)))

def __starting_point():
    Main()

__starting_point()

N, M = map(int, input().split())
A = list(map(int, input().split()))
a = sum(A)
base = 10 ** 9 + 7
# * pow(a, base-2, base) # equivalent to division by a

# ans = comb(M+N, a+N)

def fact(x):
  r = 1
  for i in range(1,x+1):
    r *= i
    r %= base
  return r

ans = 1
for i in range(a+N):
  ans *= M+N-i
  ans %= base
ans *= pow(fact(a+N), base-2, base)
ans %= base
print(ans)

def comb(n,m):
  p=10**9+7
  
  inv=[0]*(m+1)
  finv=[0]*(m+1)
  inv[1]=1
  finv[0]=1
  finv[1]=1
  for i in range(2,m+1):
    inv[i]=(-(p//i)*inv[p%i])%p
    finv[i]=finv[i-1]*inv[i]%p
  
  if m>n:
    return 0
  elif n<0 or m<0:
    return 0
  else:
    #print(inv)
    #print(finv)
    ans=1
    for i in range(n,n-m,-1):
      ans=(ans*i)%p
      
    return (ans*finv[m])%p
  
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
s=sum(a)
print((comb(m+n,s+n)))



k = 72
kk = k // 4
K = 1<<k
# nu = lambda L: int("".join([hex(K+a)[3:] for a in L[::-1]]), 16)
def nu(L, sl = -1):
    if sl == -1: sl = slice(0,len(L))
    return int("".join([hex(K+a)[3:] for a in L[sl][::-1]]), 16)
st = lambda n: hex(n)[2:]
li = lambda s, l, r: [int(a, 16) % P if len(a) else 0 for a in [s[-(i+1)*kk:-i*kk] for i in range(l, r)]]

def grow(d, v, h, start):
    h += [0] * d
    f = [(-1 if (i+d) % 2 else 1) * fainv[i] * fainv[d-i] % P * h[i] % P for i in range(d+1)]
    nuf = nu(f)
    a = d * inv[v] % P
    t = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        t[i] = t[i-1] * (a - d + i - 1) % P
    ti = [1] * (3*d+3)
    ti[-1] = pow(t[-1], P-2, P)
    for i in range(1, 3*d+3)[::-1]:
        ti[i-1] = ti[i] * (a - d + i - 1) % P
    iv = [1] * (3*d+3)
    for i in range(1, 3*d+3):
        iv[i] = ti[i] * t[i-1] % P
 
    ###
    fg = li(st(nuf * nu(iv[1:2*d+2])), d, d * 2 + 1)
    for i, (_fg, _ti) in enumerate(zip(fg, ti)):
        h[i] = h[i] * (_fg * t[d+i+1] % P * _ti % P) % P
 
    ###
    fg1 = li(st(nuf * nu(inv[1:2*d+2])), d, d * 2 + 1)
    fg2 = li(st(nuf * nu(iv[d+2:3*d+3])), d, d * 2 + 1)
    fg1.pop()
    for i, (_fg1, _fg2) in enumerate(zip(fg1, fg2)):
        h[i+d+1] = _fg1 * fa[d+i+1] % P * fainv[i] % P * (_fg2 * t[2*d+i+2] % P * ti[d+i+1] % P) % P
 
    return h

# Create a table of the factorial of the first v+2 multiples of v, i.e., [0!, v!, 2v!, ..., (v(v+1))!]
def create_table(v, start):
    s = 1
    X = [start, v + start]
    while s < v:
        X = grow(s, v, X, start)
        s *= 2
 
    table = [1]
    for x in X:
        table.append(table[-1] * x % P)
    return table

def fact(i, table):
    a = table[i//v]
    for j in range(i//v*v+1, i+1):
        a = a * j % P
    return a

P = 10 ** 9 + 7
nn = 4000000
v = 1 << (nn.bit_length() + 1) // 2
fa = [1] * (2*v+2)
fainv = [1] * (2*v+2)
for i in range(2*v+1):
    fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(2*v+1)[::-1]:
    fainv[i] = fainv[i+1] * (i+1) % P
inv = [0] * (2*v+2)
for i in range(1, 2*v+2):
    inv[i] = fainv[i] * fa[i-1] % P

def prod(a, b, vv): # a * (a + 1) * ... * (b - 1) % P
    T = create_table(vv, a)
    c = b - a
    s = T[c//vv]
    for i in range(c // vv * vv + a, b):
        s = s * i % P
    return s

def C(a, b):
    if b * 2 > a: b = a - b
    return prod(a - b + 1, a + 1, v) * pow(prod(1, b + 1, v), P - 2, P) % P

N, M = list(map(int, input().split()))
A = [int(a) for a in input().split()]
s = sum(A)
print((C(N + M, s + N) if M >= s else 0))


import sys

N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
P = int(1e9+7)
sumA=sum(A)
# 値が大きくmod Pな時
def comb(n, r):
    if n < r or r < 0:
        return 0
    nume = 1
    deno = 1
    for i in range(1, r + 1):
        nume = (nume * (n - i + 1)) % P
        deno = (deno* i ) % P
    deno_inv = pow(deno, P-2, P)
    return nume*deno_inv%P

print((comb(M+N, N+sumA)))