// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



using i32 = std::int_fast32_t;

using i64 = std::int_fast64_t;

template <typename T> constexpr T inf = numeric_limits<T>::has_infinity ? numeric_limits<T>::infinity() : numeric_limits<T>::max() / 4;



#define REP(i, stop) FOR(i, 0, stop)

#define FOR(i, start, stop) for (int i = start, i##_len = stop; i < i##_len; ++i)

#define RREP(i, n) for (int i = n; i-- > 0;)

#define ALL(v) (v).begin(), (v).end()

#define RALL(v) (v).rbegin(), (v).rend()

#define COMP(key) [](const auto& a, const auto& b) { return a.key < b.key; }



template<typename T, typename U> istream& operator>>(istream& is, pair<T, U>& a) { return is >> a.first >> a.second; }

template<typename T> istream& operator>>(istream& is, vector<T>& a) { for (T& x : a) is >> x; return is; }



void LOG(const int& x) { cerr << x << "\n"; }

template<typename T> void LOG(const vector<T>& a) { for (const T& x : a) cerr << x << " "; cerr << "\n"; }

template<typename T, std::size_t S> void LOG(const T (&a)[S]) { REP(i, S) cerr << a[i] << " "; cerr << "\n"; }

template<typename T, std::size_t S, std::size_t R> void LOG(const T (&a)[S][R]) { REP(i, S) { REP(j, R) cerr << a[i][j] << " "; cerr << "\n"; } }



i64 ceil(i64 a, i64 b) { return (a - 1) / b + 1; }

i64 gcd(i64 a, i64 b) { while (b != 0) { i64 t = b; b = a % b; a = t; } return a; }

i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }

i64 gcd(const vector<i64>& v) { return accumulate(ALL(v), 1LL, static_cast<i64(*)(i64, i64)>(gcd)); }

i64 lcm(const vector<i64>& v) { return v.empty() ? 0LL : accumulate(v.begin() + 1, v.end(), v[0], static_cast<i64(*)(i64, i64)>(lcm)); }

i64 pow(i64 x, i64 y, i64 z) { i64 a = 1; while (y > 0) { if (y & 1) a = a * x % z; x = x * x % z; y /= 2; } return a; }

i64 inv(i64 x, i64 m) { return pow(x, m - 2, m); }



struct InitCpp { InitCpp() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(10); } } initCpp;



const i64 INF = inf<i64>;

using P = pair<i64, i64>;

using T = pair<i64, P>;

const i64 M = 1000000007;

signed main() {

  i64 N, M;

  cin >> N >> M;

  vector<i64> A(N);

  cin >> A;

  sort(ALL(A));

  vector<i64> S(N + 1);

  REP(i, N) S[i + 1] = S[i] + A[i];

  i64 h_ng = 0;

  i64 h_ok = A[N - 1] * 2 + 2;

  i64 h = h_ok;

  i64 s = 0;

  i64 q = 0;

  i64 r = 0;

  i64 ans = 0;

  while (h_ok > h_ng + 1) {

    h = (h_ok + h_ng) / 2;

    s = 0;

    q = 0;

    r = 0;

    REP(i, N) {

      i64 ge = lower_bound(ALL(A), h - A[i]) - A.begin();

      i64 gt = upper_bound(ALL(A), h - A[i]) - A.begin();

      q += N - gt;

      r += gt - ge;

      s += S[N] - S[gt] + A[i] * (N - gt);

    }

    if (q <= M) {

      h_ok = h;

      if (M <= q + r) {

        cout << (s + (M - q) * h) << endl;

        exit(0);

      }

    } else {

      h_ng = h;

    }

  }

  exit(1);

}


// Faster C++ solution for the same problem (measured speedup: 1.1099481836405902x):
#include <cstdio>

#include <algorithm>

#include <vector>

using namespace std;



using i64 = long long;



#define REP(i, n) for (int i = 0, i##_len = n; i < i##_len; ++i)

#define RREP(i, n) for (int i = n; i-- > 0;)



const int is = 1 << 17;

char ib[is], *ip = ib + is, it;

inline char getc() {

	if (ip == ib + is) { fread_unlocked(ib, 1, is, stdin); ip = ib; }

	return *ip++;

}

inline i64 read() {

	i64 r = 0;

	if (ip + 16 > ib + is) while ((it = getc()) & 16) r = r * 10 + it - '0';

	else while ((it = *ip++) & 16) r = r * 10 + it - '0';

	return r;

}



const int os = 1 << 17;

char ob[os], *op = ob, ot;

inline void putc(const char c) {

	*op++ = c;

	if (op == ob + os) { fwrite_unlocked(ob, 1, os, stdout); op = ob; }

}

// x shoud be greater than or equal to zero

inline void write(i64 x) {

	char d[20];

	int i = 0;

	while (true) {

		d[i] = x % 10 + 48;

		x /= 10;

		++i;

		if (x <= 0) break;

	}

	while (i--) {

		putc(d[i]);

	}

}



signed main() {

  i64 N = read();

  i64 M = read();

  vector<i64> A(N);

  REP(i, N) A[i] = read();

  sort(A.begin(), A.end());

  vector<i64> S(N + 1);

  REP(i, N) S[i + 1] = S[i] + A[i];

  i64 h_ng = 0;

  i64 h_ok = A[N - 1] * 2 + 1;

  i64 h = h_ok;

  i64 ans = 0;

  while (h_ok > h_ng + 1) {

    h = h_ng + h_ok >> 1;

    i64 s = 0;

    i64 q = 0;

    i64 gt = 0;

    RREP(i, N) {

      while (gt < N && !(A[i] + A[gt] > h)) gt++;

      q += N - gt;

      s += S[N] - S[gt] + A[i] * (N - gt);

    }

    if (q <= M) {

      h_ok = h;

      ans = s + (M - q) * h;

    } else {

      h_ng = h;

    }

  }

  write(ans);

  fwrite_unlocked(ob, 1, op - ob, stdout);

}