// Template
#include <bits/stdc++.h>
#define rep_override(x, y, z, name, ...) name
#define rep2(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep3(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define rep(...) rep_override(__VA_ARGS__, rep3, rep2)(__VA_ARGS__)
#define per(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
constexpr int inf = 1001001001;
constexpr ll INF = 3003003003003003003;
template <typename T> inline bool chmin(T& x, const T& y) {if (x > y) {x = y; return 1;} return 0;}
template <typename T> inline bool chmax(T& x, const T& y) {if (x < y) {x = y; return 1;} return 0;}
struct IOSET {IOSET() {cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(10);}} ioset;

// Number-Theoretical Transform
// for example, (998244353, 31), (1012924417, 198), (1811939329, 136)
template <int mod, int base>
struct NumberTheoreticalTransform {
    vector<ll> zeta, inv_zeta;
    NumberTheoreticalTransform() {
        size_t exponents = 0;
        int tmp = mod - 1;
        while (not (tmp & 1)) {
            tmp >>= 1;
            ++exponents;
        }
        zeta.resize(exponents + 1);
        inv_zeta.resize(exponents + 1);
        zeta[exponents] = base;
        inv_zeta[exponents] = mod_pow(base, mod - 2);
        for (size_t i = exponents; i > 0; --i) {
            zeta[i - 1] = zeta[i] * zeta[i] % mod;
            inv_zeta[i - 1] = inv_zeta[i] * inv_zeta[i] % mod;
        }
    }
    ll mod_pow(ll x, ll y) {
        if (not y) return 1;
        ll a = mod_pow(x, y >> 1);
        if (y & 1) return a * a % mod * x % mod;
        return a * a % mod;
    }
    inline ll add(ll x, ll y) {
        if ((x += y) >= mod) x -= mod;
        return x;
    }
    void dft(vector<ll> &a, size_t exponents) {
        size_t m = 1 << exponents, now_e = exponents;
        while (m > 1) {
            for (size_t i = 0; i < a.size() / m; ++i) {
                ll now = 1;
                for (size_t j = 0; j < m / 2; ++j) {
                    ll l = a[m * i + j];
                    ll r = a[m * i + j + m / 2];
                    a[m * i + j] = add(l, r);
                    a[m * i + j + m / 2] = add(l, mod - r) * now % mod;
                    now = now * zeta[now_e] % mod;
                }
            }
            m >>= 1;
            --now_e;
        }
    }
    void idft(vector<ll> &a, size_t exponents) {
        size_t m = 2, now_e = 1;
        while (m <= a.size()) {
            for (size_t i = 0; i < a.size() / m; ++i) {
                ll now = 1;
                for (size_t j = 0; j < m / 2; ++j) {
                    ll l = a[m * i + j];
                    ll r = a[m * i + j + m / 2] * now % mod;
                    a[m * i + j] = add(l, r);
                    a[m * i + j + m / 2] = add(l, mod - r);
                    now = now * inv_zeta[now_e] % mod;
                }
            }
            m <<= 1;
            ++now_e;
        }
    }
    vector<ll> multiply(vector<ll> f, vector<ll> g) {
        size_t siz = 1, exp = 0;
        while (siz < f.size() + g.size()) {
            siz *= 2;
            ++exp;
        }
        vector<ll> nf(siz, 0), ng(siz, 0);
        for (size_t i = 0; i < f.size(); ++i) nf[i] = f[i];
        for (size_t i = 0; i < g.size(); ++i) ng[i] = g[i];
        dft(nf, exp);
        dft(ng, exp);
        for (size_t i = 0; i < siz; ++i) nf[i] = nf[i] * ng[i] % mod;
        idft(nf, exp);
        ll inv = mod_pow(siz, mod - 2);
        for (size_t i = 0; i < siz; ++i) nf[i] = nf[i] * inv % mod;
        return nf;
    }
};

// Main
int main() {
    constexpr int MAX_A = 100000;
    NumberTheoreticalTransform<998244353, 31> ntt1;
    NumberTheoreticalTransform<1012924417, 198> ntt2;
    
    int n; ll m;
    cin >> n >> m;
    vector<int> a(n);
    rep(i, n) cin >> a[i];
    
    vector<ll> cnt(MAX_A + 1, 0);
    rep(i, n) ++cnt[a[i]];
    vector<ll> mul1 = ntt1.multiply(cnt, cnt), mul2 = ntt2.multiply(cnt, cnt);
    vector<ll> mul(2 * MAX_A + 1);
    rep(i, 2 * MAX_A + 1) {
        ll t = mul2[i] - mul1[i];
        if (t < 0) t += 1012924417;
        t *= ntt2.mod_pow(998244353, 1012924415);
        t %= 1012924417;
        mul[i] = mul1[i] + 998244353 * t;
    }
    
    ll ans = 0;
    for (int i = MAX_A * 2; i >= 0; --i) {
        ans += i * min(m, mul[i]);
        m -= min(m, mul[i]);
    }
    cout << ans << "\n";
    return 0;
}


Measured memory_bytes: 12132