// // #define LawrenceSivan
// #pragma GCC optimize(2)
// #pragma GCC optimize(3,"Ofast","inline")

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

// using i64 = long long;
// using ull = unsigned long long;
// using d64 = long double;

// #define INF 0x3f3f3f3f
// // #define int i64

// constexpr int maxn = 1e5 + 5;
// constexpr int base = 131;
// constexpr double eps = 1e-8;

// const int N = 1e5;
// vector <int> G[N + 3];
// std::vector<int>ed;
// bool in[N + 3];
// bool dfs2(int u, int fa, int mst) {
//     if (u != fa && u == mst) {
//         ed.push_back(u);
//         in[u] = 1;
//         return true;
//     }

//     for (int v : G[u]) {
//         if (v == fa) continue;

//         if (dfs2(v, u, mst)) {
//             ed.push_back(u);
//             in[u] = 1;
//             return true;
//         }
//     }

//     return false;
// }
// const int p = 1145141;
// const int pp = 13331;
// const int mod = 998244353;
// ull P[2 * N + 3];

// i64 PP[2 * N + 3];
// struct Hash {
//     int len;
//     ull h;
//     i64 h2;
//     friend Hash operator + (const Hash &x, const int &y) {
//         Hash z;
//         z.len = x.len + 1;
//         z.h = x.h * p + y;
//         z.h2 = ((x.h2 * pp) % mod + y) % mod;

//         return z;
//     }
//     friend Hash operator + (const Hash &x, const Hash &y) {
//         Hash z;
//         z.len = x.len + y.len;
//         z.h = x.h * P[y.len] + y.h;
//         z.h2 = ((x.h2 * PP[y.len]) % mod + y.h2) % mod;
//         return z;
//     }
//     friend bool operator < (const Hash &x, const Hash &y) {
//         if (x.len == y.len) {
//             if (x.h == y.h)
//                 return x.h2 < y.h2;
//             else return x.h < y.h;
//         }

//         return x.len < y.len;
//     }
//     friend bool operator == (const Hash &x, const Hash &y) {
//         return x.len == y.len && x.h == y.h && x.h2 == y.h2;
//     }
// };
// Hash has[N + 3];
// std::vector<Hash>tmp;
// std::map<std::pair<int, int>, bool>ex;
// void calc(int u, int fa) {

//     for (int v : G[u]) {
//         if (in[v]) continue;

//         if (v == fa) continue;

//         calc(v, u);
//     }

//     Hash ans = {0, 0};
//     ans = ans + 1;
//     tmp.clear();

//     for (int v : G[u]) {
//         if (in[v]) continue;

//         if (v == fa) continue;

//         tmp.push_back(has[v]);
//     }

//     std::sort(tmp.begin(), tmp.end());

//     for (Hash it : tmp) {
//         ans = ans + it;
//     }

//     ans = ans + 2;
//     has[u] = ans;
// }
// inline void solve() {
//     int n, m;
//     cin >> n >> m;

//     for (int i = 1; i <= n; ++i) {
//         G[i].clear();
//     }

//     int self = 0;

//     for (int i = 1, u, v; i <= m; i++) {
//         cin >> u >> v;

//         if (u == v) {
//             self++;
//             continue;
//         }

//         G[u].push_back(v);
//         G[v].push_back(u);
//     }

//     if (m - self == n - 1) {
//         cout << "YES" << endl;
//         return;
//     }

//     vector <int> vis(n + 1);
//     ex.clear();
//     function <void(int, int)> dfs = [&](int u, int fa) {
//         vis[u]++;

//         for (auto v : G[u]) {
//             if (v == fa)continue;

//             if (ex.find(std::make_pair(u, v)) == ex.end())
//                 ex[std::make_pair(u, v)] =
//                     ex[std::make_pair(v, u)] = 1;
//             else continue;

//             if (vis[v]) {
//                 vis[v]++;
//                 continue;
//             }

//             dfs(v, u);
//         }
//     };
//     dfs(1, 1);
//     int allnum = 0;
//     int rt = 0;

//     for (int i = 1; i <= n; i++) {
//         in[i] = 0;

//         if (vis[i] >= 2)allnum++, rt = i;

//         if (vis[i] > 2) {
//             cout << "NO" << endl;
//             return;
//         }
//     }

//     if (allnum >= 2) {
//         cout << "NO" << endl;
//         return;
//     }

//     ed.clear();
//     dfs2(rt, rt, rt);

//     ed.pop_back();

//     if (ed.size() % 2 == 0) {
//         Hash H0 = {0, 0};
//         Hash H1 = {0, 0};

//         for (int i = 0; i < ed.size(); i += 2) {
//             int u1 = ed[i], u2 = ed[i + 1];
//             calc(u1, u1);

//             if (H0.len == 0) {
//                 H0 = has[u1];
//             } else {
//                 if (!(H0 == has[u1])) {
//                     cout << "NO" << endl;
//                     return;
//                 }
//             }

//             calc(u2, u2);

//             if (H1.len == 0) {
//                 H1 = has[u2];
//             } else {
//                 if (!(H1 == has[u2])) {
//                     cout << "NO" << endl;
//                     return;
//                 }
//             }
//         }
//     } else {
//         Hash H0 = {0, 0};

//         for (int u : ed) {
//             calc(u, u);

//             if (H0.len == 0) {
//                 H0 = has[u];
//             } else {
//                 if (!(H0 == has[u])) {
//                     cout << "NO" << endl;
//                     return;
//                 }
//             }
//         }
//     }

//     cout << "YES" << endl;
// }

// signed main() {
// #ifdef LawrenceSivan
//     // freopen("a.in", "r", stdin);
//     freopen("a.txt", "w", stdout);
// #endif
//     ios::sync_with_stdio(0);

//     int T = 1;
//     cin >> T;
//     P[0] = 1;

//     for (int i = 1; i <= N * 2; ++i) {
//         P[i] = P[i - 1] * p;
//     }

//     PP[0] = 1;

//     for (int i = 1; i <= N * 2; ++i) {
//         PP[i] = (i64)PP[i - 1] * pp % mod;
//     }

//     while (T--) {
//         solve();
//     }

//     return 0;
// }
// /*
// 1
// 6 6
// 1 2
// 2 3
// 2 4
// 3 5
// 4 5
// 5 6

// */



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

using ll = long long;

int n, m;
ll exgcd(ll a, ll b, ll &x, ll &y) {
    if (!b) {
        x = 1;
        y = 0;
        return a;
    }

    ll d = exgcd(b, a % b, y, x);
    y -= (a / b) * x;
    return d;
}

int main() {
    cin >> n >> m;
    ll sum = 0;

    for (int i = 1; i <= n; ++i) {
        int x;
        cin >> x;
        sum += x;
    }

    ll s = 0, d = 0, k = 0, t = 0;
    ll g = exgcd(n, 1ll * n * (n + 1) / 2, s, d);
    ll g2 = exgcd(g, m, k, t);
    s *= k;
    d *= k;
    sum %= m;
    g2 %= m;
    printf("%lld\n", sum % g2);
    ll t2 = sum / g2;
    int S = (m - (s * t2 % m + m) % m) % m;
    int D = (m - (d * t2 % m + m) % m) % m;
    printf("%d %d\n", S, D);
    return 0;
}