#include <bits/stdc++.h>

using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
// #define int long long
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000 //2e9
#define LLINF 100000000000000000ll // 1e17
#define fi first
#define sec second
#define all(x) (x).begin(),(x).end()
#define sq(x) ((x)*(x))
#define dmp(x) cerr << #x << ": " << x << endl;

template<class T> void chmin(T& a,const T& b){if(a>b)a=b;}
template<class T> void chmax(T& a,const T& b){if(a<b)a=b;}

template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T,vector<T>,greater<T>>;
template<class T> vector<T> vect(int len,T elem){ return vector<T>(len,elem); }

template<class T,class U>
ostream& operator << (ostream& os,const pair<T,U>& p){
  os << p.fi << ',' << p.sec; return os;
}
template<class T,class U>
istream& operator >> (istream& is,pair<T,U>& p){
  is >> p.fi >> p.sec; return is;
}
template<class T>
ostream& operator << (ostream &os,const vector<T> &vec){
  for(int i=0;i<vec.size();i++){
    os << vec[i];
    if(i+1<vec.size())os << ' ';
  }
  return os;
}
template<class T>
istream& operator >> (istream &is,vector<T>& vec){
  for(int i=0;i<vec.size();i++)is >> vec[i];
  return is;
}
void fastio(){
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout<<fixed<<setprecision(20);
}

// matrix class
// constructor of T : T(1),T(0) must be unit of T
template <class T>
struct Matrix{
  int H,W;
  vector<vector<T>> elem;
  Matrix(int H,int W,T val = T(0)):H(H),W(W){
    elem.resize(H);
    for(int i=0;i<H;i++)elem[i].assign(W,val);
  }
  Matrix(const vector<vector<T>> &m) : H(m.size()), W(m.size() ? m[0].size() : 0) {
    elem.resize(H);
    for(int i=0;i<H;i++)elem[i].resize(W);
    for(int i=0;i<H;i++) elem[i] = m[i];
  }
  vector<T>& operator [] (int h) {
    return elem[h];
  }
  static Matrix identity(int N) {
    Matrix a(N,N);
    for(int i=0;i<N;i++){
      for(int j=0;j<N;j++){
        if(i==j)a.elem[i][i] = T(1);
        else a.elem[i][j] = T(0);
      }
    }
    return a;
  }
  Matrix operator + (const Matrix &m) const {
    assert( H==m.H && W==m.W );
    Matrix a(H,W);
    for(int i=0;i<H;i++){
      for(int j=0;j<W;j++){
        a.elem[i][j] = this->elem[i][j] + m.elem[i][j];
      }
    }
    return a;
  }
  Matrix operator - (const Matrix &m) const {
    assert( H==m.H && W==m.W );
    Matrix a(H,W);
    for(int i=0;i<H;i++){
      for(int j=0;j<W;j++){
        a.elem[i][j] = this->elem[i][j] - m.elem[i][j];
      }
    }
    return a;
  }
  Matrix operator * (const Matrix &m) const {
    assert( W == m.H );
    Matrix a(H,m.W);
    for(int i=0;i<H;i++){
      for(int j=0;j<m.W;j++){
        for(int k=0;k<W;k++){
          a.elem[i][j] = a.elem[i][j] + (this->elem[i][k] * m.elem[k][j]);
        }
      }
    }
    return a;
  }
  Matrix &operator+= (const Matrix &m) { return *this = *this + m; }
  Matrix &operator-= (const Matrix &m) { return *this = *this - m; }
  Matrix &operator*= (const Matrix &m) { return *this = *this * m; }
  Matrix pow(long long x) const {
    Matrix a = identity(H);
    Matrix b = *this;
    while(x){
      if(x&1)a *= b;
      b *= b;
      x >>= 1;
    }
    return a;
  }
  friend ostream & operator << (ostream &os, const Matrix &x) {
    for(int i=0;i<x.H;i++){
      for(int j=0;j<x.W;j++){
        os << x.elem[i][j];
        if(j+1<x.W)cout << ' ';
      }
      if(i+1<x.H)cout << endl;
    }
    return os;
  }
  friend istream & operator >> (istream &is, Matrix &x) {
    for(auto &v : x.elem) is >> v;
    return is;
  }
};

namespace Math{
  template<int MOD> // if inv is needed, this shold be prime.
  struct ModInt{
    ll val;
    ModInt():val(0ll){}
    ModInt(const ll& v):val(((v%MOD)+MOD)%MOD){}
    bool operator==(const ModInt& x)const{return val==x.val;}
    bool operator!=(const ModInt& x)const{return !(*this==x);}
    bool operator<(const ModInt& x)const{return val<x.val;}
    bool operator>(const ModInt& x)const{return val>x.val;}
    bool operator>=(const ModInt& x)const{return !(*this<x);}
    bool operator<=(const ModInt& x)const{return !(*this>x);}
    ModInt operator-()const{return ModInt(MOD-val);}
    ModInt inv()const{return this->pow(MOD-2);}
    ModInt& operator+=(const ModInt& x){if((val+=x.val)>=MOD)val-=MOD;return *this;}
    ModInt& operator-=(const ModInt& x){if((val+=MOD-x.val)>=MOD)val-=MOD;return *this;}
    ModInt& operator*=(const ModInt& x){(val*=x.val)%=MOD;return *this;}
    ModInt& operator/=(const ModInt& x){return *this *= x.inv();};
    ModInt operator+(const ModInt& x)const{return ModInt(*this)+=x;}
    ModInt operator-(const ModInt& x)const{return ModInt(*this)-=x;}
    ModInt operator*(const ModInt& x)const{return ModInt(*this)*=x;}
    ModInt operator/(const ModInt& x)const{return ModInt(*this)/=x;}
    friend istream& operator>>(istream&i,ModInt& x){ll v;i>>v;x=v;return i;}
    friend ostream& operator<<(ostream&o,const ModInt& x){o<<x.val;return o;}
    ModInt pow(ll x)const{
      auto res = ModInt(1ll);
      auto b = *this;
      while(x){
        if(x&1)res *= b;
        x >>= 1;
        b *= b;
      }
      return res;
    }
  };

  template<int MOD>
  ModInt<MOD> pow(ModInt<MOD> a,ll x){
    ModInt<MOD> res = ModInt<MOD>(1ll);
    while(x){
      if(x&1)res *= a;
      x >>= 1;
      a *= a;
    }
    return res;
  }

  constexpr int MOD = 1e9+7;
  // constexpr int MOD = 998244353;
  using mint = ModInt<MOD>;

  vector<mint> inv,fac,facinv;
  // notice: 0C0 = 1 
  ModInt<MOD> nCr(int n,int r){
    assert(!(n<r));
    assert(!(n<0||r<0));
    return fac[n]*facinv[r]*facinv[n-r];
  }
  void init(int SIZE){
    fac.resize(SIZE+1);
    inv.resize(SIZE+1);
    facinv.resize(SIZE+1);
    fac[0] = inv[1] = facinv[0] = mint(1ll);
    for(int i=1;i<=SIZE;i++)fac[i]=fac[i-1]*mint(i);
    for(int i=2;i<=SIZE;i++)inv[i]=mint(0ll)-mint(MOD/i)*inv[MOD%i];
    for(int i=1;i<=SIZE;i++)facinv[i]=facinv[i-1]*inv[i];
    return;
  }
  template<class T>
  int digit(T x){
    int res = 0;
    while(x){ x /= T(10); res++; }
    return res;
  }
  template<class T>
  int digit_sum(T x){
    int res = 0;
    while(x){ res+=x%10; x/=10; }
    return res;
  }
  template<class T>
  T gcd(T x,T y){
    if(y==T(0))return x;
    else return gcd(y,x%y);
  }
}

using namespace Math;
mint dp[22][1010];

signed main(){
  fastio();
  int N,K;
  cin >> N >> K;
  vector<int> a(K);
  init(100000);
  cin >> a;
  dp[0][0] = mint(1);
  for(int i=0;i<K;i++){
    for(int j=0;j<=N;j++){
      for(int k=0;k<=min(a[i],N-j);k++){
        dp[i+1][j+k] += dp[i][j] * nCr(N-k,a[i]-k) * nCr(N-j,k);
      }
    }
  }
  cout << dp[K][N] << endl;
  return 0;
}


Measured memory_bytes: 2816