// #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <assert.h>
#include <climits>
#include <iomanip>
using namespace std;

#define int uint16_t
void solve([[maybe_unused]] int t)
{
  int n, m;
  cin >> n >> m;
  // n = 30;
  // m = 10;
  vector<int> a(m);
  for (auto &i : a)
    cin >> i;
  // i = n / 2;

  vector<map<int, int>> dp(m);

  auto hash = [](vector<int> &v) -> int
  {
    vector<int> freq(31);
    for (auto i : v)
      freq[i]++;

    long long ans = 0, base = 47;
    for (auto i : freq)
    {
      ans *= base;
      ans += i + 1;
    }
    return ans;
  };

  vector<int> curr;
  curr.reserve(n);
  auto calc = [&](auto &calc, vector<int> &v, int ind, int x, set<vector<int>> &opz) -> void
  {
    if (ind == v.size())
    {
      if (x == 0)
      {
        opz.insert(curr);
      }
      return;
    }

    for (int i = 0; i <= min(v[ind], x); i++)
    {
      if (i)
        curr.push_back(i);
      if (v[ind] - i)
        curr.push_back(v[ind] - i);

      calc(calc, v, ind + 1, x - i, opz);

      if (v[ind] - i)
        curr.pop_back();
      if (i)
        curr.pop_back();
    }
  };

  auto f = [&](auto &f, vector<int> v, int ind)
  {
    int cont = 0;
    for (auto i : v)
      if (i == 1)
        cont++;
    if (ind == m)
    {
      return cont;
    }
    if (cont == n)
      return cont;

    sort(v.begin(), v.end());
    if (dp[ind].count(hash(v)))
      return dp[ind][hash(v)];

    int res = 0;
    set<vector<int>> opz;
    calc(calc, v, 0, a[ind], opz);
    vector<vector<int>> vv;
    vv.reserve(opz.size());
    for (auto i : opz)
      vv.push_back(i);

    sort(vv.begin(), vv.end(), [](auto &i, auto &j)
         { return i.size() > j.size(); });
    for (auto &i : vv)
    {
      res = max(res, f(f, i, ind + 1));
      if (res == n)
      {
        cout << n << "\n";
        exit(0);
      }
    }

    return dp[ind][hash(v)] = res;
  };

  vector<int> st = {n};
  cout << signed(f(f, st, 0)) << "\n";
}

signed main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n = 1;
  // cin >> n;
  for (int i = 1; i <= n; i++)
    solve(i);
}