#include <bits/stdc++.h>
template <uint32_t Mod>
class IntMod {
  static_assert(Mod != 0, "Mod must not be 0");
  static_assert(Mod < 0x80000000, "Mod must be less than 0x80000000");

 private:
  uint32_t value_m;

 public:
  IntMod();
  IntMod(int32_t value);
  IntMod(uint32_t value);
  IntMod(int64_t value);
  IntMod(uint64_t value);
  const IntMod<Mod>& operator+() const;
  IntMod<Mod> operator-() const;
  IntMod<Mod>& operator++();
  IntMod<Mod>& operator--();
  IntMod<Mod> operator++(int dummy);
  IntMod<Mod> operator--(int dummy);
  IntMod<Mod>& operator+=(const IntMod<Mod>& right);
  IntMod<Mod>& operator-=(const IntMod<Mod>& right);
  IntMod<Mod>& operator*=(const IntMod<Mod>& right);
  IntMod<Mod>& operator/=(const IntMod<Mod>& right);
  IntMod<Mod> operator[](uint64_t exp) const;
  static IntMod<Mod> add(const IntMod<Mod>& a, const IntMod<Mod>& b);
  static IntMod<Mod> subtract(const IntMod<Mod>& a, const IntMod<Mod>& b);
  static IntMod<Mod> multiply(const IntMod<Mod>& a, const IntMod<Mod>& b);
  static IntMod<Mod> divide(const IntMod<Mod>& a, const IntMod<Mod>& b);
  static int compare(const IntMod<Mod>& a, const IntMod<Mod>& b);
  IntMod<Mod> inverse() const;
  IntMod<Mod> power(uint64_t exp) const;
  uint32_t get() const;
  static IntMod<Mod> fact(uint32_t num);
  static IntMod<Mod> combi(uint32_t n, uint32_t r);
  static IntMod<Mod> homcombi(uint32_t n, uint32_t r);
  static IntMod<Mod> perm(uint32_t n, uint32_t r);
  static std::vector<IntMod<Mod>> calcInverseList(int max);
};
template <uint32_t Mod>
IntMod<Mod> operator+(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod> operator-(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod> operator*(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod> operator/(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator+(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator-(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator*(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator/(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator+(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator-(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator*(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
IntMod<Mod> operator/(const Int& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator==(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator!=(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator<(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator<=(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator>(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
bool operator>=(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod, class Int>
bool operator==(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod, class Int>
bool operator!=(const IntMod<Mod>& a, const Int& b);
template <uint32_t Mod>
std::istream& operator>>(std::istream& ist, IntMod<Mod>& object);
template <uint32_t Mod>
std::ostream& operator<<(std::ostream& ost, const IntMod<Mod>& object);
using MInt = IntMod<1000000007>;
namespace std {
template <uint32_t Mod>
struct hash<IntMod<Mod>> {
  size_t operator()(const IntMod<Mod>& object) const {
    return std::hash<uint32_t>()(object.get());
  }
};
}  // namespace std
template <uint32_t Mod>
uint32_t discreteLog(const IntMod<Mod>& a, const IntMod<Mod>& b);
template <uint32_t Mod>
IntMod<Mod>::IntMod() : value_m(0) {}
template <uint32_t Mod>
IntMod<Mod>::IntMod(int32_t value) {
  int32_t tmp = value % int32_t(Mod);
  value_m = tmp >= 0 ? tmp : Mod - uint32_t(-tmp);
}
template <uint32_t Mod>
IntMod<Mod>::IntMod(uint32_t value) : value_m(value % Mod) {}
template <uint32_t Mod>
IntMod<Mod>::IntMod(int64_t value) {
  int32_t tmp = value % int64_t(Mod);
  value_m = tmp >= 0 ? tmp : Mod - uint32_t(-tmp);
}
template <uint32_t Mod>
IntMod<Mod>::IntMod(uint64_t value) : value_m(value % Mod) {}
template <uint32_t Mod>
const IntMod<Mod>& IntMod<Mod>::operator+() const {
  return *this;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator-() const {
  IntMod<Mod> ret;
  if (value_m == 0) {
    ret.value_m = 0;
  } else {
    ret.value_m = Mod - value_m;
  }
  return ret;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator++() {
  ++value_m;
  if (value_m == Mod) {
    value_m = 0;
  }
  return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator--() {
  if (value_m == 0) {
    value_m = Mod;
  }
  --value_m;
  return *this;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator++(int dummy) {
  IntMod ret(*this);
  ++*this;
  return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator--(int dummy) {
  IntMod ret(*this);
  --*this;
  return ret;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator+=(const IntMod<Mod>& right) {
  value_m += right.value_m;
  if (value_m >= Mod) {
    value_m -= Mod;
  }
  return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator-=(const IntMod<Mod>& right) {
  if (value_m < right.value_m) {
    value_m += Mod;
  }
  value_m -= right.value_m;
  return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator*=(const IntMod<Mod>& right) {
  value_m = (uint64_t(value_m) * right.value_m) % Mod;
  return *this;
}
template <uint32_t Mod>
IntMod<Mod>& IntMod<Mod>::operator/=(const IntMod<Mod>& right) {
  *this *= right.inverse();
  return *this;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::operator[](uint64_t exp) const {
  return power(exp);
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::add(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  IntMod<Mod> ret(a);
  ret += b;
  return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::subtract(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  IntMod<Mod> ret(a);
  ret -= b;
  return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::multiply(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  IntMod<Mod> ret(a);
  ret *= b;
  return ret;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::divide(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  IntMod<Mod> ret(a);
  ret /= b;
  return ret;
}
template <uint32_t Mod>
int IntMod<Mod>::compare(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  if (a.value_m < b.value_m) return -1;
  if (a.value_m > b.value_m) return 1;
  return 0;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::inverse() const {
  assert(value_m != 0);
  return power(Mod - 2);
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::power(uint64_t exp) const {
  IntMod<Mod> product(1);
  IntMod<Mod> factor(*this);
  while (exp > 0) {
    if (exp & 1) {
      product *= factor;
    }
    factor *= factor;
    exp >>= 1;
  }
  return product;
}
template <uint32_t Mod>
uint32_t IntMod<Mod>::get() const {
  return value_m;
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::fact(uint32_t num) {
  assert(num <= 0x80000000);
  static std::vector<IntMod<Mod>> table(1, 1);
  if (table.size() > num) return table[num];
  int old_size = table.size();
  table.resize(num + 1);
  for (int i = old_size; i <= num; ++i) {
    table[i] = table[i - 1] * i;
  }
  return table[num];
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::combi(uint32_t n, uint32_t r) {
  assert(n >= r);
  return fact(n) / (fact(n - r) * fact(r));
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::homcombi(uint32_t n, uint32_t r) {
  assert(n != 0 || r == 0);
  if (n == 0 && r == 0) return IntMod<Mod>(1);
  return combi(n + r - 1, r);
}
template <uint32_t Mod>
IntMod<Mod> IntMod<Mod>::perm(uint32_t n, uint32_t r) {
  assert(n >= r);
  return fact(n) / fact(n - r);
}
template <uint32_t Mod>
std::vector<IntMod<Mod>> IntMod<Mod>::calcInverseList(int max) {
  assert(max < Mod);
  std::vector<IntMod<Mod>> table(max + 1);
  table[1] = 1;
  for (int i = 2; i <= max; ++i) {
    table[i] = (uint64_t(Mod - Mod / i) * table[Mod % i].get()) % Mod;
  }
  return table;
}
template <uint32_t Mod>
IntMod<Mod> operator+(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::add(a, b);
}
template <uint32_t Mod>
IntMod<Mod> operator-(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::subtract(a, b);
}
template <uint32_t Mod>
IntMod<Mod> operator*(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::multiply(a, b);
}
template <uint32_t Mod>
IntMod<Mod> operator/(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::divide(a, b);
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator+(const IntMod<Mod>& a, const Int& b) {
  return a + IntMod<Mod>(b);
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator-(const IntMod<Mod>& a, const Int& b) {
  return a - IntMod<Mod>(b);
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator*(const IntMod<Mod>& a, const Int& b) {
  return a * IntMod<Mod>(b);
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator/(const IntMod<Mod>& a, const Int& b) {
  return a / IntMod<Mod>(b);
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator+(const Int& a, const IntMod<Mod>& b) {
  return IntMod<Mod>(a) + b;
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator-(const Int& a, const IntMod<Mod>& b) {
  return IntMod<Mod>(a) - b;
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator*(const Int& a, const IntMod<Mod>& b) {
  return IntMod<Mod>(a) * b;
}
template <uint32_t Mod, class Int>
IntMod<Mod> operator/(const Int& a, const IntMod<Mod>& b) {
  return IntMod<Mod>(a) / b;
}
template <uint32_t Mod>
bool operator==(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::compare(a, b) == 0;
}
template <uint32_t Mod>
bool operator!=(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::compare(a, b) != 0;
}
template <uint32_t Mod>
bool operator<(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::compare(a, b) < 0;
}
template <uint32_t Mod>
bool operator<=(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::compare(a, b) <= 0;
}
template <uint32_t Mod>
bool operator>(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::compare(a, b) > 0;
}
template <uint32_t Mod>
bool operator>=(const IntMod<Mod>& a, const IntMod<Mod>& b) {
  return IntMod<Mod>::compare(a, b) >= 0;
}
template <uint32_t Mod, class Int>
bool operator==(const IntMod<Mod>& a, const Int& b) {
  return a == IntMod<Mod>(b);
}
template <uint32_t Mod, class Int>
bool operator!=(const IntMod<Mod>& a, const Int& b) {
  return a != IntMod<Mod>(b);
}
template <uint32_t Mod>
std::istream& operator>>(std::istream& ist, IntMod<Mod>& object) {
  uint64_t value;
  ist >> value;
  object = IntMod<Mod>(value);
  return ist;
}
template <uint32_t Mod>
std::ostream& operator<<(std::ostream& ost, const IntMod<Mod>& object) {
  ost << object.get();
  return ost;
}
using namespace std;
using uint = uint32_t;
using LL = int64_t;
using ULL = uint64_t;
using PP = pair<LL, LL>;
template <typename T>
using PriorityQ = priority_queue<T, vector<T>, greater<T>>;
const int INF = 0x3FFFFFFF;
const LL INFLL = 0x3FFFFFFF3FFFFFFF;
const double INFD = 1.0e+308;
const double EPS = 1.0e-9;
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
template <class T, class U>
istream& operator>>(istream& ist, pair<T, U>& right) {
  return ist >> right.first >> right.second;
}
template <class T, class U>
ostream& operator<<(ostream& ost, const pair<T, U>& right) {
  return ost << right.first << ' ' << right.second;
}
template <class T, class TCompatible, size_t N>
void Fill(T (&dest)[N], const TCompatible& val) {
  fill(dest, dest + N, val);
}
template <class T, class TCompatible, size_t M, size_t N>
void Fill(T (&dest)[M][N], const TCompatible& val) {
  for (int i = 0; i < M; ++i) Fill(dest[i], val);
}
template <class T>
T Next() {
  T buf;
  cin >> buf;
  return buf;
}
istream& Ignore(istream& ist) {
  string s;
  ist >> s;
  return ist;
}
bool Inside(int i, int j, int h, int w) {
  return i >= 0 && i < h && j >= 0 && j < w;
}
istream& operator>>(istream& ist, __int128& val) {
  LL tmp;
  ist >> tmp;
  val = tmp;
  return ist;
}
ostream& operator<<(ostream& ost, __int128 val) {
  LL tmp = val;
  ost << tmp;
  return ost;
}
int N, K;
int A[1000];
MInt DP[21][1001];
MInt comb(int n, int k) {
  if (n < 0 || k < 0) return 0;
  return MInt::combi(n, k);
}
int main() {
  cin >> N >> K;
  for (LL k = (0), k_max_ = (K); k < k_max_; ++k) {
    cin >> A[k];
  }
  DP[0][0] = 1;
  for (LL k = (1), k_max_ = (K + 1); k < k_max_; ++k) {
    for (LL n = (0), n_max_ = (N + 1); n < n_max_; ++n) {
      for (LL x = (0), x_max_ = (n + 1); x < x_max_; ++x) {
        DP[k][n] += DP[k - 1][n - x] * MInt(k - 1).power(n - x) * comb(n, x) *
                    comb(N - x, A[k - 1] - x);
      }
      DP[k][n] /= MInt(k).power(n) * comb(N, A[k - 1]);
    }
  }
  MInt ans = DP[K][N];
  for (LL k = (0), k_max_ = (K); k < k_max_; ++k) {
    ans *= comb(N, A[k]);
  }
  ans *= MInt(K).power(N);
  cout << ans << endl;
  return 0;
}
