#include <bits/stdc++.h>

#define int uint16_t
using namespace std;

const int MN = 32;
const int MM = 16;
int n,m;
array<int,MM> a;
const array<int,31> nbit = { 0, 0, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
array<int,31> indb = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

inline int gsiz(uint64_t bs, int i) {
	return (bs>>indb[i])&((int(1)<<nbit[i])-1);
}
inline void gadd(uint64_t& bs, int i) {
	bs += uint64_t(1)<<indb[i];
}
inline void grem(uint64_t& bs, int i) {
	bs -= uint64_t(1)<<indb[i];
}
int score(uint64_t bs) {
	int ans = n;
	for(int i=2; i<=30; ++i) ans-=gsiz(bs, i)*i;
	return ans;
}
void dbg(uint64_t bs) {
	for(int i=2; i<=30; ++i) for(int _=0; _<gsiz(bs,i); ++_) {
		cerr<<i<<' ';
	}
	cerr<<endl;
}

void calc(const uint64_t nop, const uint64_t op, const int i, const int nb, int md, int one, vector<uint64_t>& opz) {
	if(i==1) {
		if(nb<=score(op+nop)-one) opz.push_back(op+nop);
		return;
	}
	md=min(md,int(i-1));
	md=min(md,nb);
	if(md && gsiz(op,i)) {
		for(int d=1; d<=md; ++d) {
			uint64_t op2 = op;
			uint64_t nop2 = nop;
			grem(op2,i);
			if(d>1) gadd(nop2,d);
			if(i-d>1) gadd(nop2,i-d);
			calc(nop2, op2, i, nb-d, d, int(one+(d==1)+(i-d==1)), opz);
		}
	}
	calc(nop, op, i-1, nb, nb, one, opz);
}

unordered_set<uint64_t> memo[31];
int bnb(uint64_t bs, int ai) {
	if(ai==m) return score(bs);
	if(memo[ai].count(bs)) return 0;
	memo[ai].insert(bs);
	int ub=n;

	vector<uint64_t> nxt;
	calc(0,bs,30,a[ai],a[ai],0,nxt);
	sort(nxt.begin(), nxt.end());
	uint64_t last = -1;

	int res=0;
	for(auto &nbs:nxt) if(nbs!=last) {
		last=nbs;
		res=max(res,bnb(nbs,ai+1));
		if(res==ub) break;
	}
	return res;
}

signed main() {
	cin.tie(0);
	ios_base::sync_with_stdio(0);
	for(int i=1; i<=30; ++i) indb[i]=indb[i-1]+nbit[i-1];
	
	cin>>n>>m;
	for(int i=0; i<m; ++i) {
		cin>>a[i];
		if(n-a[i]<a[i]) a[i]=n-a[i];
	}

	uint64_t b0=0;
	gadd(b0,n);

	cout<<bnb(b0,0)<<endl;


	return 0;
}