#ifndef LOCAL_RUN
	#define NDEBUG
#endif
#ifdef GNU_DEBUG
	#define _GLIBCXX_DEBUG 1
	#define _GLIBCXX_DEBUG_PEDANTIC 1
	#define _GLIBCXX_SANITIZE_VECTOR 1
#endif
#include <bits/stdc++.h>
namespace {
#define mset(a, b) memset(&a, b, sizeof(a))
#define ALL(v) std::begin(v), std::end(v)
#define RANGE(a, l, r) (std::begin(a) + (l)), (std::begin(a) + ((r) + 1))
#define fir(i, a, b, ...) for (int i = (a), ##__VA_ARGS__; i <= (b); ++i)
#define firr(i, a, b, ...) for (int i = (a), ##__VA_ARGS__; i >= (b); --i)
#ifdef LOCAL_RUN
	template<class T> void dbgpr(const T& x) {std::cerr << x << std::endl;}
	template<class T, class... Args> void dbgpr(const T& x, const Args&... args) {std::cerr << x << ", ", dbgpr(args...);}
	template<class... Args> void dbgprint(const char* s, const Args&... args) {std::cerr << s << " = ", dbgpr(args...);}
	#define debug(...) dbgprint(#__VA_ARGS__, __VA_ARGS__)
	#define DEBUG if (true)
#else
	#define debug(...) void()
	#define DEBUG if (false)
#endif
typedef long long LL;
typedef long double LD;
typedef unsigned long long ULL;
template<class T> void rei(T& x) {
	bool f = false; int ch; x = 0;
	while (!isdigit(ch = getchar())) f = ch == '-';
	do x = x * 10 + (ch & 15); while (isdigit(ch = getchar()));
	if (f) x = -x;
}
template<class T1, class T2> bool cmax(T1& a, const T2& b) {return a < b ? a = b, true : false;}
template<class T1, class T2> bool cmin(T1& a, const T2& b) {return b < a ? a = b, true : false;}
using namespace std;

const int MOD = 1e9 + 7;
inline int llmod(LL x) {assert(x >= 0); return int(x % MOD);}
inline int mod1(int x) {assert(0 <= x && x < 2 * MOD); return x < MOD ? x : x - MOD;}
inline int mod2(int x) {assert(-MOD <= x && x < MOD);  return x >=  0 ? x : x + MOD;}
inline void madd(int& x, int y) {x = mod1(x + y);}
inline void msub(int& x, int y) {x = mod2(x - y);}
inline void mtim(int& x, int y) {x = llmod((LL)x * y);}
inline void maddtim(int& x, int y, int z) {x = llmod(x + (LL)y * z);}
inline int qpow(int a, int b = MOD - 2) {
	int ans = 1;
	for (; b; b >>= 1) {
		if (b & 1) mtim(ans, a);
		mtim(a, a);
	}
	return ans;
}

const int MAXN = 35;
const int MAXS = 1.5e6 + 5;

int n, m, full;
array<int, MAXN> d;

vector<int> state;
unordered_map<int, int> id;

void dfs_enum(int idx, int msk) {
	if (idx == n) {
		state.push_back(msk);
		return;
	}
	dfs_enum(idx + 1, msk);
	if (idx >= d[1] && !(msk >> (idx - d[1]) & 1)) return;
	dfs_enum(idx + 1, msk | 1 << idx);
}

array<unsigned, 5> multi;
void solve(int msk) {
	static array<unsigned, MAXN> arr;
	fir (i, 0, n - 1) {
		if (msk >> i & 1) {
			arr[i] = 1U << 31 | 1U << i;
		} else {
			arr[i] = 0;
		}
	}
	ULL sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;
	fir (idx, 1, m) {
		int len = d[idx];
		fir (i, len, n - 1) {
			if (arr[i]) {
				for (int j = i; j >= len && arr[j - len]; j -= len) {
					arr[j - len] |= arr[j];
					arr[j] = 1U << 31;
				}
			} else {
				for (int j = i; j >= len && arr[j - len]; j -= len) {
                    sum0 += arr[j - len] & 0b00000010000100001000010000100001U;
                    sum1 += arr[j - len] & 0b00000100001000010000100001000010U;
                    sum2 += arr[j - len] & 0b00001000010000100001000010000100U;
                    sum3 += arr[j - len] & 0b00010000100001000010000100001000U;
                    sum4 += arr[j - len] & 0b00100001000010000100001000010000U;
					arr[j] = arr[j - len];
					arr[j - len] = 0;
				}
			}
		}
	}
	multi = {unsigned(sum0), unsigned(sum1 >> 1), unsigned(sum2 >> 2), unsigned(sum3 >> 3), unsigned(sum4 >> 4)};
}
int calc(int key) {
    return multi[key % 5] >> (key - key % 5) & 31;
}

array<int, MAXS> mx, cnt;

void realmain() {
	// freopen("data.in", "r", stdin);
	rei(n), rei(m), full = (1 << n) - 1;
	fir (i, 1, m) rei(d[i]);
	dfs_enum(0, 0);
	id.reserve(state.size());
	fir (i, 0, (int)state.size() - 1) id[state[i]] = i;
	debug(state.size());
	assert(!state[0]), assert(state.back() == full);
	cnt[0] = 1;
	fir (cur, 1, (int)state.size() - 1) {
		int S = state[cur];
		solve(S);
		fir (i, 0, n - 1) if (S >> i & 1) if ((LL)~S >> (i + d[1]) & 1) {
			assert(id.count(S ^ 1 << i));
			int t = id[S ^ 1 << i];
			int r1 = calc(i);
			int r2 = mx[t];
			int r3 = cnt[t];
			if (cmax(mx[cur], r1 + r2)) cnt[cur] = r3;
			else if (mx[cur] == r1 + r2) madd(cnt[cur], r3);
		}
	}
	assert(id.size() == state.size());
	printf("%d %d\n", mx[(int)state.size() - 1], cnt[(int)state.size() - 1]);
}}
signed main(){return realmain(),0;}