#include <bits/stdc++.h>
using namespace std;
constexpr int N=505,P=1e9+7;
int n,m,c[N],fac[N],fi[N];
int f[2][N][N],ad[N][N],fs[N][N];
constexpr inline int qp(int a,int b){
	int c{1};
	for(;b;a=1ll*a*a%P,b>>=1) if(b&1) c=1ll*c*a%P;
	return c;
}
constexpr inline int inv(int x){return qp(x,P-2);}
inline void add(int &a,int b){
	if((a+=b)>=P) a-=P;
}
inline int cc(int n,int m){
	if(m<0||n<m) return 0;
	return 1ll*fac[n]*fi[n-m]%P*fi[m]%P;
}
int main(){
	//ifstream cin("suffix.in"); ofstream cout("suffix.out");
	cin.tie(0)->sync_with_stdio(0);
	int m0;
	cin>>n>>m0;
	while(m0--){
		int t; cin>>t;
		if(t) c[++m]=t;
	}
	fac[0]=1; for(int i{1};i<N;++i) fac[i]=1ll*fac[i-1]*i%P;
	fi[N-1]=inv(fac[N-1]); for(int i{N-2};i>=0;--i) fi[i]=1ll*fi[i+1]*(i+1)%P;
	f[0][0][0]=1;
	int ans{0};
	for(int i{1};i<=m;++i){
		memset(ad,0,sizeof ad),memset(fs,0,sizeof fs);
		for(int j{0};j<=n;++j) for(int k{0};k<=n;++k){
			if(j>0) fs[j][k]=fs[j-1][k];
			add(fs[j][k],f[!(i&1)][j][k]);
		}
		for(int jl{1};jl<=n;++jl){
			for(int k{0};k<=jl;++k){
				if(jl-c[i]<=0)
					add(f[i&1][jl][jl],1ll*fs[jl-1][k]*fi[jl-k]%P);
				else
					add(f[i&1][jl][jl],1ll*(fs[jl-1][k]-fs[max(0,jl-c[i]-1)][k]+P)*fi[jl-k]%P);
			}
		}
		for(int j{0};j<=n;++j){
			for(int k{0};k<=n;++k){
				int &me{f[!(i&1)][j][k]};
				if(!me) continue;
				if(j+c[i]<=n) add(f[i&1][j+c[i]][k],me);
				int lmx=min(c[i],n-j);
				if(lmx>=1){
					add(ad[j+1][k],(P-me)%P);
					if(j+lmx+1<=n) add(ad[j+lmx+1][k],me);
				}
				me=0;
			}
		}
		for(int j{1};j<=n;++j){
			for(int k{0};k<=n;++k){
				if(j>0) add(ad[j][k],ad[j-1][k]);
				add(f[i&1][j][k],ad[j][k]);
			}
		}
		add(ans,f[i&1][n][n]);
	}
	ans=1ll*ans*fac[n]%P;
	cout<<ans<<'\n';
	return 0;
}

/*
bananas:
2 4 6 1 3 5 7
ananans
anas
as
bananas
nanas
nas
s

考虑判定后缀数组
直接考虑定义，suf(sa[i])<suf(sa[i+1])
(定义 rk[n+1]=0)
s[sa[i]]<=s[sa[i+1]]	(rk[sa[i]+1]<rk[sa[i+1]+1])
s[sa[i]]<s[sa[i+1]]		(rk[sa[i]+1]>rk[sa[i+1]+1])
显然是充要条件

每个后缀数组对应一个不等式链 s[sa[1]]<(=)s[sa[2]]<(=)s[sa[3]]<(=)...<(=)s[sa[n]]
判定后缀数组合法：构造不等式链，判定不等式链是否能构造出来（合法）

判定一个不等式链合法：
如果没有 c 的限制，只需要 m>=cnt(<)+1
有，根据 < 分段，从左往右贪心，每段尽量用当前字符填满，填不满就全填上到后一个字符

统计有多少个 sa 对应某个不等式链：
定义"秩"：最少的字符种类数，使得可以构造出这个后缀数组
后缀数组的秩等于不等式链中 < 的个数+1=分成的段数
考虑统计秩为 m 的满足某个不等式链后缀数组数量
用 m 种字符构造的后缀数组，秩 <=m
（或说：考虑每一段 <= 的字符都相同的情况，满足这个条件的每个字符串都对应不同的后缀数组）
方案为 C(n,len1,len2,len3,...,len[k])=C(n,len1)*C(n-len1,len2)*C(n-len1-len2,len3)*...*C(n-len1-len2-...-len[k-1],len[k])
这样需要减去 <m 的
枚举哪个应该为 < 的地方实际是 <=
例如：[len1] < [len2] < [len3]
如果第一个 < 是 <=，方案 C(n,len1+len2,len3)
第二个是，方案 C(n,len1,len2+len3)
多减了都是 < 的，C(n,len1+len2+len3)
。。。
容斥，cnt[秩为 m] = sum (i=1..m) sum(a[1..i],s.t. sum a=n) (-1)^(m-k)*C(n,a[1],a[2],...,a[i]) 
		(约分)	  = sum(...) (-1)^(m-k)*fac[n]*prod fi[a[i]]
				 = fac[n]*sum(...) (-1)^(m-k)*prod fi[a[i]]

原问题：
考虑统计秩=1..m 的后缀数组数量
有 c 的限制，不影响，多种字符可以合并成一段（但是一种字符不能分到多段）
dp，
f[i][j][k]: 考虑了前 i 种字符，当前填了的所有段的长度和为 j，上一个 < 在第 k 个字符之后，对答案的贡献
拼接在当前段之后，不结束当前段：f[i][j+c[i]][k]+=f[i-1][j][k]
拼接在当前段之后并结束，填 <：f[i][j+l][j+l]+=fi[j+l-k]*f[i-1][j][k]
拼接在当前段之后并结束，填 <=：f[i][j+l][k]+=(-1)*f[i-1][j][k]

ans=fac[n]*sum(i=1..m) f[i][n][n]

O(n^3m)
用前缀和和差分优化 O(n^2m)
*/