#include <bits/stdc++.h>
using namespace std;
using vint = vector<long long>;
using vvint = vector<vint>;
using pint = pair<long long, long long>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double PI = 3.1415926535897932384626433832795028;
constexpr long long DY[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long long DX[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
long long sign(long long x) { return (x > 0) - (x < 0); }
long long gcd(long long a, long long b) {
  while (b) {
    swap(a %= b, b);
  }
  return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long cdiv(long long a, long long b) { return (a - 1 + b) / b; }
template <typename T>
void fin(T mes) {
  cout << mes << endl;
  exit(0);
}
template <typename T, typename U>
bool chmax(T &a, const U &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T, typename U>
bool chmin(T &a, const U &b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &rhs) {
  os << "(" << rhs.first << ", " << rhs.second << ")";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &rhs) {
  os << "{";
  for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
    os << *itr << (next(itr) != rhs.end() ? ", " : "");
  }
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &rhs) {
  os << "{";
  for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
    os << *itr << (next(itr) != rhs.end() ? ", " : "");
  }
  os << "}";
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &rhs) {
  os << "{";
  for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
    os << *itr << (next(itr) != rhs.end() ? ", " : "");
  }
  os << "}";
  return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &rhs) {
  os << "{";
  for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
    os << *itr << (next(itr) != rhs.end() ? ", " : "");
  }
  os << "}";
  return os;
}
struct setup {
  static constexpr long long PREC = 20;
  setup() {
    cout << fixed << setprecision(PREC);
    cerr << fixed << setprecision(PREC);
  };
} setup;
template <long long MOD = 1000000007>
struct mod_int {
  long long val;
  mod_int(long long val_ = 0) : val(val_ % MOD) {
    if (val < 0) {
      val += MOD;
    }
  }
  bool operator==(const mod_int &rhs) const { return val == rhs.val; }
  bool operator!=(const mod_int &rhs) const {
    return std::rel_ops::operator!=(*this, rhs);
  }
  mod_int &operator+=(const mod_int &rhs) {
    if ((val += rhs.val) >= MOD) {
      val -= MOD;
    }
    return *this;
  }
  mod_int &operator-=(const mod_int &rhs) {
    if ((val += MOD - rhs.val) >= MOD) {
      val -= MOD;
    }
    return *this;
  }
  mod_int &operator*=(const mod_int &rhs) {
    val = (long long)((long long)val * rhs.val % MOD);
    return *this;
  }
  mod_int &operator/=(const mod_int &rhs) { return *this *= rhs.inv(); }
  mod_int operator+() const { return *this; }
  mod_int operator-() const { return -val; }
  mod_int operator++() { return *this += 1; }
  mod_int operator--() { return *this -= 1; }
  mod_int operator++(signed) {
    const mod_int ret(*this);
    ++*this;
    return ret;
  }
  mod_int operator--(signed) {
    const mod_int ret(*this);
    --*this;
    return ret;
  }
  mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
  mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
  mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
  mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
  mod_int inv() const {
    assert(val != 0);
    long long a = val, b = MOD, x = 1, u = 0;
    while (b) {
      long long t = a / b;
      std::swap(a -= t * b, b);
      std::swap(x -= t * u, u);
    }
    return x;
  }
  mod_int pow(long long n) const {
    if (n < 0) {
      return pow(-n).inv();
    }
    mod_int ret = 1, mul = *this;
    while (n) {
      if (n & 1) {
        ret *= mul;
      }
      mul *= mul;
      n >>= 1;
    }
    return ret;
  }
  friend std::istream &operator>>(std::istream &is, mod_int &rhs) {
    long long v;
    is >> v;
    rhs = v;
    return is;
  }
  friend std::ostream &operator<<(std::ostream &os, const mod_int &rhs) {
    return os << rhs.val;
  }
  struct combination {
    std::vector<mod_int> fact{1, 1}, f_inv{1, 1}, inv{0, 1};
    void calc(long long n) {
      while (fact.size() <= n) {
        long long i = fact.size();
        fact.push_back(fact[i - 1] * i);
        inv.push_back(-inv[MOD % i] * (MOD / i));
        f_inv.push_back(f_inv[i - 1] * inv[i]);
      }
    }
    mod_int P(long long n, long long r) {
      return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[n - r]);
    }
    mod_int C(long long n, long long r) {
      return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[r] * f_inv[n - r]);
    }
    mod_int H(long long n, long long r) { return C(n + r - 1, r); }
  };
};
template <typename T>
void fft(std::vector<T> &x, const std::vector<T> &w) {
  long long n = x.size();
  long long m = n >> 1;
  std::vector<T> y(n);
  for (long long i = 1; i <= m; i <<= 1) {
    for (long long j = 0; j < m; j += i) {
      for (long long k = 0; k < i; k++) {
        long long u = j + k;
        y[(u << 1) + 0] = (x[u + 0] + x[u + m]);
        y[(u << 1) + 1] = (x[u + 0] - x[u + m]) * w[j];
      }
    }
    std::swap(x, y);
  }
}
template <typename T>
void ifft(std::vector<T> &x, const std::vector<T> &w) {
  long long n = x.size();
  long long m = n >> 1;
  std::vector<T> y(n);
  for (long long i = m; i > 0; i >>= 1) {
    for (long long j = 0; j < m; j += i) {
      for (long long k = 0; k < i; k++) {
        long long u = j + k;
        x[(u << 1) + 1] *= w[j];
        y[u + 0] = x[(u << 1) + 0] + x[(u << 1) + 1];
        y[u + m] = x[(u << 1) + 0] - x[(u << 1) + 1];
      }
    }
    std::swap(x, y);
  }
  T n_inv = T(1) / n;
  for (long long i = 0; i < n; i++) {
    x[i] *= n_inv;
  }
}
template <long long MOD, long long ROOT>
std::vector<long long> friendly_mod_convolute(const std::vector<long long> &a,
                                              const std::vector<long long> &b) {
  long long n_a = a.size(), n_b = b.size();
  long long n_ = n_a + n_b - 1, n;
  for (n = 1; n < n_; n <<= 1) {
  }
  long long m = n >> 1;
  std::vector<mod_int<MOD>> a_mint(n), b_mint(n), w(m + 2);
  std::copy(a.begin(), a.end(), a_mint.begin()),
      std::copy(b.begin(), b.end(), b_mint.begin());
  w[0] = 1, w[1] = mod_int<MOD>(ROOT).pow((MOD - 1) / n);
  for (long long i = 2; i < m; i++) {
    w[i] = w[i - 1] * w[1];
  }
  fft(a_mint, w);
  fft(b_mint, w);
  for (long long i = 0; i < n; i++) {
    a_mint[i] *= b_mint[i];
  }
  w[1] = w[1].inv();
  for (long long i = 2; i < m; i++) {
    w[i] = w[i - 1] * w[1];
  }
  ifft(a_mint, w);
  std::vector<long long> ret(n_);
  for (long long i = 0; i < n_; i++) {
    ret[i] = a_mint[i].val;
  }
  return ret;
}
template <long long K = 3>
std::vector<long long> arbitrary_mod_convolute(const std::vector<long long> &a,
                                               const std::vector<long long> &b,
                                               long long mod) {
  static constexpr long long MS[] = {998244353, 469762049, 167772161},
                             RS[] = {3, 3, 3};
  auto safe_mod = [](long long a, long long m) -> long long {
    a %= m;
    if (a < 0) {
      a += m;
    }
    return a;
  };
  auto mod_inv = [&](long long a, long long m) -> long long {
    long long b = m, x = 1, u = 0;
    while (b) {
      long long t = a / b;
      std::swap(a -= t * b, b);
      std::swap(x -= t * u, u);
    }
    return safe_mod(x, m);
  };
  long long n_a = a.size(), n_b = b.size();
  long long n_ = n_a + n_b - 1, n;
  for (n = 1; n < n_; n <<= 1) {
  }
  std::vector<long long> m(K + 1), prod_m(K + 1, 1);
  std::vector<std::vector<long long>> ret(K + 1, std::vector<long long>(n_));
  std::copy(MS, MS + K, m.begin());
  m[K] = mod;
  for (long long i = 0; i < K; i++) {
    std::vector<long long> piece;
    if (i == 0) {
      piece = friendly_mod_convolute<MS[0], RS[0]>(a, b);
    }
    if (i == 1) {
      piece = friendly_mod_convolute<MS[1], RS[1]>(a, b);
    }
    if (i == 2) {
      piece = friendly_mod_convolute<MS[2], RS[2]>(a, b);
    }
    long long prod_inv = mod_inv(prod_m[i], m[i]);
    for (long long j = 0; j < n_; j++) {
      long long mod_m_i =
          (long long)safe_mod(piece[j] - ret[i][j], m[i]) * prod_inv % m[i];
      for (long long k = i + 1; k <= K; k++) {
        ret[k][j] = (ret[k][j] + (long long)mod_m_i * prod_m[k] % m[k]) % m[k];
      }
    }
    for (long long j = i + 1; j <= K; j++) {
      prod_m[j] = (long long)prod_m[j] * m[i] % m[j];
    }
  }
  return ret[K];
}
using mint = mod_int<>;
signed main() {
  long long N, K;
  cin >> N >> K;
  mint::combination comb;
  comb.calc(N);
  vint a(K), res{1};
  for (long long i = 0; i < (long long)(K); i++) {
    cin >> a[i];
    vint cur(a[i] + 1);
    for (long long j = 0; j < (long long)(a[i] + 1); j++) {
      cur[j] = (comb.C(N - j, a[i] - j) * comb.f_inv[j]).val;
    }
    res = arbitrary_mod_convolute<2>(res, cur, 1e9 + 7);
    res.resize(N + 1);
  }
  mint ans = res[N];
  ans *= comb.fact[N];
  cout << ans << endl;
}
