#include <iostream>
#include <vector>
#include <numeric>
using i64 = long long;

std::vector<long long> fact, inv;

constexpr auto pow(long long x, long long n, const long long mod) {
    long long ret = 1;
    while(n > 0) {
        if ((n & 1) == 1) ret = (ret * x) % mod;
        x = (x * x) % mod;
        n >>= 1;
    }
    return ret;
}

constexpr auto inverse(const long long x, const long long p) {
    return pow(x, p - 2, p);
}

void init_factorial(const int n, const long long mod) {
    fact.resize(n + 1);
    inv.resize(n + 1);
    fact[0] = 1;
    for (long long i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
    inv[n] = inverse(fact[n], mod);
    for (long long i = n; i > 0; i--) inv[i - 1] = inv[i] * i % mod;
}

int main() {
    constexpr i64 mod = 1000000007;
    int n, k;
    std::cin >> n >> k;
    init_factorial(n, mod);
    std::vector<int> a(k);
    for(auto &e : a) std::cin >> e;

    auto f = [&](int i, int j) { return fact[n - j] * inv[n - a[i]] % mod * inv[a[i] - j] % mod; };

    const int s = std::accumulate(a.begin(), a.end(), 0);

    std::vector<i64> dp(s + 1);
    dp[0] = 1;
    for (int i = 0; i < k; i++) {
        std::vector<i64> next(s + 1);
        for (int j = 0; j <= s; j++) for (int l = 0; j + l <= s && l <= a[i]; l++) {
            next[j + l] = (next[j + l] + dp[j] * f(i, l) % mod * inv[l] % mod) % mod;
        }
        std::swap(dp, next);
    }

    std::cout << dp[n] * fact[n] % mod << std::endl;

    return 0;
}
