#include <bits/stdc++.h>
using namespace std;

#define fi first
#define se second
#define mk make_pair

const int MAXS = 28628;
const int MAXPairs = 6e5;

int n, m;
int cnt;
int num[35], num2[35];

map<vector<int>, int> mp;
vector<int> vecs[MAXS + 5];
int sum[MAXS + 5], num1[MAXS + 5];
vector<int> state[35];

void dfs(vector<int> v, int cursum) {
	assert(v.size());
	assert(!mp[v]);
	
	mp[v] = ++cnt;
	vecs[cnt] = v;
	sum[cnt] = cursum;
	for (int i = 0; i < (int)v.size(); ++i) {
		num1[cnt] += (v[i] == 1);
	}
	
	state[cursum].push_back(cnt);
	
	for (int i = v.back(); cursum + i <= n; ++i) {
		v.push_back(i);
		dfs(v, cursum + i);
		v.pop_back();
	}
}

int a[15];
int cnt_pairs;
pair<int, int> states_pairs[MAXPairs + 5];
map<pair<int, int>, int> mp_pairs;

bool dp[31][16][MAXPairs + 5];

void print(vector<int> v) {
	cout << "[";
	for (int i = 0; i < (int)v.size(); ++i) {
		cout << v[i] << ", ";
	}
	cout << "]" << endl;
}

int main() {
	cin >> n >> m;
	for (int i = 1; i <= m; ++i) {
		cin >> a[i];
		a[i] = min(a[i], n - a[i]); // to reduce constant
	}
	
	// n = 30;
	
	for (int i = 1; i <= n; ++i) {
		vector<int> v;
		v.push_back(i);
		dfs(v, i);
	}
	
	for (int i = 1; i <= n; ++i) {
		for (int j = 0; j < (int)state[i].size(); ++j) {
			for (int k = 0; k < (int)state[n - i].size(); ++k) {
				states_pairs[++cnt_pairs] = mk(state[i][j], state[n - i][k]);
				mp_pairs[mk(state[i][j], state[n - i][k])] = cnt_pairs;
			}
		}
	}
	for (int j = 0; j < (int)state[n].size(); ++j) {
		states_pairs[++cnt_pairs] = mk(state[n][j], 0); // do not split anything
		mp_pairs[mk(state[n][j], 0)] = cnt_pairs;
	}
	for (int k = 0; k < (int)state[n].size(); ++k) {
		states_pairs[++cnt_pairs] = mk(0, state[n][k]); // split everything (do not leave anything)
		mp_pairs[mk(0, state[n][k])] = cnt_pairs;
	}
	
	vector<int> v;
	v.push_back(n);
	
	dp[0][0][mp_pairs[mk(mp[v], 0)]] = 1;
	
	for (int i = 1; i <= m; ++i) {
		for (int k = 1; k <= cnt_pairs; ++k) {
			if (dp[i - 1][0][k]) {
				if (num1[states_pairs[k].fi] + num1[states_pairs[k].se] == n) {
					cout << n << endl;
					return 0;
				}
				
				vector<int> v1 = vecs[states_pairs[k].fi], v2 = vecs[states_pairs[k].se];
				for (int t = 0; t < (int)v2.size(); ++t) {
					v1.push_back(v2[t]);
				}
				sort(v1.begin(), v1.end());
				// assert(mp[v1] != 0);
				dp[i][a[i]][mp_pairs[mk(mp[v1], 0)]] = 1;
			}
		}
		
		for (int j = a[i]; j >= 1; --j) { // number of 1s remaining
			for (int k = 1; k <= cnt_pairs; ++k) { // current state: (unsplitted, splitted)
				if (dp[i][j][k]) {
					vector<int> v1 = vecs[states_pairs[k].fi], v2 = vecs[states_pairs[k].se];
					if (v1.size()) {
						int l = v1.size() - 1;
						for (int x = 1; x < v1[l] && x <= j; ++x) { // use x 1s to split that element
							vector<int> nv1, nv2 = v2;
							for (int t = 0; t < (int)v1.size(); ++t)
								if (t != l)
									nv1.push_back(v1[t]);
							nv2.push_back(x);
							nv2.push_back(v1[l] - x);
							sort(nv2.begin(), nv2.end());
							// assert(mp[nv2] != 0);
							dp[i][j - x][mp_pairs[mk(mp[nv1], mp[nv2])]] = 1;
						}
						if (j >= v1[l]) {
							vector<int> nv1, nv2 = v2;
							for (int t = 0; t < (int)v1.size(); ++t)
								if (t != l)
									nv1.push_back(v1[t]);
							nv2.push_back(v1[l]);
							sort(nv2.begin(), nv2.end());
							dp[i][j - v1[l]][mp_pairs[mk(mp[nv1], mp[nv2])]] = 1;
						}
					}
				}
			}
		}
	}
	
	int ans = 0;
	
	for (int k = 1; k <= cnt_pairs; ++k) {
		if (dp[m][0][k]) {
			ans = max(ans, num1[states_pairs[k].fi] + num1[states_pairs[k].se]);
		}
	}
	
	cout << ans << endl;
	
	return 0;
}