#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using u8 = uint8_t;
using u64 = uint64_t;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

template <typename Cb>
struct KeyCmp {
    Cb cb;

    KeyCmp(Cb cb) : cb(cb) {}

    template <typename T>
    bool operator()(const T& a, const T& b) const {
        return cb(a) < cb(b);
    }
};

struct Hasher {
    u64 x;

    Hasher& operator()(u64 v) {
        x ^= x >> 29;
        x ^= x << 37;
        x ^= x >> 17;
        x ^= x << 23;
        x ^= v;
        return *this;
    }
};

constexpr int maxn = 15, maxm = 35;

int n, m, arr[maxn];
u64 hashes[maxm];
__gnu_pbds::gp_hash_table<u64, int> memo[maxn][maxm];

template <typename T>
u64 hashv(const T& arr) {
    u64 ans = 0;
    for (auto& a : arr) {
        ans += hashes[a];
    }
    return ans;
}

int dp(int ind, int left, basic_string<u8> gen, basic_string<u8> comps) {
    if (ind == n) {
        int ans = int(count(begin(comps), end(comps), 1));
        if (ans == m) {
            cout << ans << endl;
            exit(0);
        }
        return ans;
    } else if (!sz(comps)) {
        if (left) {
            return 0;
        }
        return dp(ind + 1, arr[ind + 1], {}, gen);
    }
    u64 key = Hasher()(hashv(gen))(hashv(comps)).x;
    auto it = memo[ind][left].find(key);
    if (it != memo[ind][left].end()) {
        return it->second;
    }
    int ans = 0, cx = comps.back();
    comps.pop_back();
    for (int i = 0; i <= min(cx, left); i++) {
        auto ngen = gen;
        auto push = [&](int u) -> void {
            if (u) {
                ngen.push_back(u);
            }
        };
        push(i);
        push(cx - i);
        ans = max(ans, dp(ind, left - i, ngen, comps));
    }
    return memo[ind][left][key] = ans;
}

void solve() {
    mt19937_64 cowng(chrono::steady_clock::now().time_since_epoch().count());
    for (auto& a : hashes) {
        a = cowng();
    }
    cin >> m >> n;
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    sort(arr, arr + n, KeyCmp([&](int x) -> int {
        return min(x, m - x);
    }));
    // shuffle(arr, arr + n, cowng);
    cout << dp(0, arr[0], {}, {u8(m)}) << endl;
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}