#include <bits/stdc++.h>
#include <bits/extc++.h>

using namespace std;
using namespace __gnu_pbds;

#define fo(v,a,b) for(int v = a; v <= b; v++)
#define fr(v,a,b) for(int v = a; v >= b; v--)
#define cl(a,v) memset(a, v, sizeof(a))

typedef long long ll;

#pragma GCC optimize("Ofast")

const ll P = 1e9 + 7;
const int N = 35, M = 11;

typedef unsigned int ull;
// typedef unsigned long long ull;
const ull B = 131;

int n, m, d[M];

struct value {  int v; ll cnt;  } ;
inline value operator+(const value &a, const value &b) {
    if(a.v == b.v) return {a.v, a.cnt + b.cnt};
    if(a.v < b.v) return b;
    return a;
}

ull pw[N];
inline ull hsh(vector<int> vec) {
    ull sum = 0;
    for(int i = 0; i < (int)vec.size(); i++)
        sum += (vec[i] + 1) * pw[i];
    return sum;
}

__gnu_pbds::gp_hash_table<ull, int> mp[M];
int arr[N], rb[N][N];
void dfs(int id, int x, vector<int> now) {
    if(x == d[id]) {
        if(id == m) {
            if(now[0]) now.push_back(0), mp[id][hsh(now)] = 0;
            return ;
        }
        fo(i, 0, n - 1) arr[i] = ((i / d[id]) < now[i % d[id]]);
        vector<int> nxt; nxt.resize(d[id + 1]);
        fo(i, 0, n - 1) nxt[i % d[id + 1]] += arr[i];
        fo(i, 0, n - 1) {
            arr[i] ^= 1; if(i >= d[id + 1]) arr[i] += arr[i - d[id + 1]];
        }
        ull vNow = hsh(now), vNxt = hsh(nxt);
        fo(i, 0, d[id] - 1) if(now[i]) {
            int pos = i + (now[i] - 1) * d[id], cur = arr[pos];
            mp[id][vNow + (i + 1) * pw[d[id]]] =
                mp[id + 1][vNxt + (pos % d[id + 1] + 1) * pw[d[id + 1]]] + cur;
        }
        return ;
    }
    fo(i, 0, rb[d[id]][x]) {
        now.push_back(i);
        dfs(id, x + 1, now);
        now.pop_back();
    }
}

__gnu_pbds::gp_hash_table<ull, value> dp; value ans;
void calcDP(int cnt, int x, vector<int> now) {
    if(x == d[1]) {
        auto vv = hsh(now);
        if(cnt == 0) return dp[vv] = {0, 1}, void();
        ull vNow = hsh(now);
        fo(i, 0, d[1] - 1) if(now[i]) {
            vector<int> nxt = now; value cur = dp[vNow - pw[i]];
            // nxt[i] += 1, nxt.push_back(i);
            cur.v += mp[1][vNow + (i + 1) * pw[d[1]]];
            dp[vv] = dp[vv] + cur;
        }
        if(cnt == n) ans = dp[vv];
        return ;
    }
    fo(i, 0, rb[d[1]][x]) {
        now.push_back(i);
        calcDP(cnt + i, x + 1, now);
        now.pop_back();
    }
}

int main()
{
    // n = 30, m = 2;
    // d[1] = 10, d[2] = 1;
    // n = 30, m = 4;
    // d[1] = 10, d[2] = 9, d[3] = 5, d[4] = 1;
    scanf("%d%d", &n, &m);
    fo(i, 1, m) scanf("%d", &d[i]), d[i] = min(d[i], n);

    pw[0] = 1; fo(i, 1, n) pw[i] = pw[i - 1] * B;
    fo(u, 1, n) fo(i, 0, u - 1)
        rb[u][i] = n / u - (i >= (n % u)) + 1;

    fr(i, m, 1) dfs(i, 0, {});
    fo(i, 2, m) __gnu_pbds::gp_hash_table<ull, int>().swap(mp[i]);
    calcDP(0, 0, {});

    fo(x, 0, d[1] - 1) {
        int num = n / d[1] - (x >= (n % d[1])) + 1;
        ans.v += num * (num - 1) / 2;
    }
    printf("%d %lld\n", ans.v, ans.cnt);

    return 0;
}
/*
 
*/