#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstdlib>
#include<cassert>

#include<cmath>
#include<functional>
#include<algorithm>

#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<set>
#include<unordered_set>
#include<map>
#include<unordered_map>
#include<bitset>
#include<tuple>

#define TEST {IS_TEST=true;}
#define fi first
#define se second
#define pb(x) {push_back(x);}

using namespace std;
using ll = int_fast64_t;
using v_b = vector <bool>;
using v_ll = vector <ll>;
using str = string;
using v_str = vector <string>;
using p_ll = pair < ll,ll >;
using vv_b = vector < v_b >;
using vv_ll = vector < v_ll >;
using vp_ll = vector < p_ll >;
using vvv_ll = vector < vv_ll >;
using vvp_ll = vector < vp_ll >;

using ld = long double;
using v_ld = vector <ld>;
using vv_ld = vector<v_ld>;

bool IS_TEST=false;
ll ll_min64=1LL<<63;
ll ll_max64=~ll_min64;
ll ll_min32=1LL<<31;
ll ll_max32=~ll_min32;

ll MOD = 1000000007;

/*displaying functions for debug*/
template<class T> void show2(const T &x){cout << x;}
template<class T1,class T2> void show2(const pair<T1,T2> &x){
  cout << "{" << show2(x.first) << "," << show2(x.second) << "}";
}
template<class T> void show(const T &x){
  if (!IS_TEST) return;
  show2(x); cout <<endl;
}
template<class T> void v_show(const T &v, ll n=-1){
  if (!IS_TEST) return;
  auto itr=v.begin(); ll m=n;
  while(itr!=v.end() && m!=0 ){ show2(*itr); cout << " "; itr++; m--;}
  cout << endl;
}
template<class T> void vv_show(const T &v, ll n=-1){
  if (!IS_TEST) return;
  cout << "--------------------------------\n";
  auto itr=v.begin(); ll m=n;
  while(itr!=v.end() && m!=0 ){ v_show(*itr,n); itr++; m--;}
  cout << "--------------------------------" << endl;
}
/*--------------------------------*/

/*loading integers*/
void load(ll& x1){ cin >> x1; }
void load(ll& x1,ll& x2){ cin >> x1 >> x2; }
void load(ll& x1,ll& x2,ll& x3){ cin >> x1 >> x2 >> x3; }
void load(ll& x1,ll& x2,ll& x3,ll& x4){ cin >> x1 >> x2 >> x3 >> x4; }
void v_load(ll n, v_ll& v1, ll head=0, ll tail=0, ll init=0){
    ll m=n+head+tail; v1.assign(m,init);
    for (ll i=0;i<n;i++){ cin >> v1[i+head]; }
}
void v_load(ll n, v_ll& v1 ,v_ll& v2, ll head=0, ll tail=0, ll init=0){
    ll m=n+head+tail; v1.assign(m,init); v2.assign(m,init);
    for (ll i=0;i<n;i++){ cin >> v1[i+head] >> v2[i+head]; }
}
void v_load(ll n, v_ll& v1 ,v_ll& v2, v_ll& v3, ll head=0, ll tail=0, ll init=0){
    ll m=n+head+tail; v1.assign(m,init); v2.assign(m,init); v3.assign(m,init);
    for (ll i=0;i<n;i++){ cin >> v1[i+head] >> v2[i+head] >> v3[i+head]; }
}
void v_load(ll n, v_ll& v1 ,v_ll& v2, v_ll& v3, v_ll& v4, ll head=0, ll tail=0, ll init=0){
    ll m=n+head+tail; v1.assign(m,init); v2.assign(m,init); v3.assign(m,init); v4.assign(m,init);
    for (ll i=0;i<n;i++){ cin >> v1[i+head] >> v2[i+head] >> v3[i+head] >> v4[i+head]; }
}
/*--------------------------------*/

v_ll ll_mg(ll x1=ll_max64, ll x2=ll_max64, ll x3=ll_max64, ll x4=ll_max64){
    v_ll x{x1,x2,x3,x4};
    sort(x.begin(),x.end());
    return x;
}

template<class T> void ch_max(T& x,const T& y){ if (x>=y) return; x=y; }
template<class T> void ch_min(T& x,const T& y){ if (x<=y) return; x=y; }
template<class T,class S> void ch_max(T& x,S& xx,const T& y,const S& yy){
  if (x>=y) return; x=y; xx=yy;
}
template<class T,class S> void ch_min(T& x,S& xx,const T& y,const S& yy){
  if (x<=y) return; x=y; xx=yy;
}

template<class T> void quit(T x){cout << x << endl; exit(0);}

ll rem(ll x,ll y){ ll z=x%y; return z>=0?z:z+y; }

ll N,M,ans;
v_ll A,B;


template<ll mod, ll rt, bool inv> v_ll fft(const v_ll& x, ll n_depth=-1){
    if (n_depth<0) {n_depth=0; while (1LL<<++n_depth < x.size());}
    ll n=1LL<<n_depth;
    v_ll arr(n,0);
    v_ll temp(n,0);
    v_ll w(24,rt);
    for (ll i=22;i>=0;i--){ w[i]=w[i+1]*w[i+1]%mod; }
    for (ll i=0;i<x.size();i++){ arr[i]=x[i]; }
    ll depth,cell,n_cell;
    for (depth=1,cell=n,n_cell=1;cell>1;depth++,cell>>=1,n_cell<<=1){
        ll mul=1;
        
        for (ll i=0;i<n;i++){ temp[i]=arr[i]; }
        for (ll i=0;i<n_cell;i++){
            for (ll j=0;j<cell/2;j++){
                arr[i*cell/2+j]=(temp[i*cell+j]+mul*temp[i*cell+j+cell/2])%mod;
                arr[i*cell/2+j+n/2]=(temp[i*cell+j]+(mod-mul)*temp[i*cell+j+cell/2])%mod;
            }
            mul=mul*w[depth]%mod;
        }
    }
    if (inv) {
        ll div=1;
        for (ll i=0;i<n_depth;i++) {div*=mod/2+1; div%=mod;}
        for (ll i=0;i<n;i++){ arr[i]*=div; arr[i]%=mod; }
    }
    return arr;
}

template<ll mod=0> v_ll convolute(const v_ll& x,const v_ll& y){
    ll n_depth=0;
    vv_ll z(3,v_ll());

    while (1LL<<n_depth < max(x.size(),y.size()))n_depth++;
    n_depth++;
    
    v_ll xx,yy,zz(1LL<<n_depth,0);
    const ll mod0=998244353,mod1=897581057,mod2=880803841;
    const ll rt0=31,rt1=45,rt2=211;
    const ll rti0=128805723,rti1=139623720,rti2=567721907;

    xx=fft<mod0,rt0,false>(x,n_depth);
    yy=fft<mod0,rt0,false>(y,n_depth);
    for (ll i=0;i<1LL<<n_depth;i++) { zz[i]=(xx[i]*yy[i])%mod0; }
    z[0]=fft<mod0,rti0,true>(zz,n_depth);
    xx=fft<mod1,rt1,false>(x,n_depth);
    yy=fft<mod1,rt1,false>(y,n_depth);
    for (ll i=0;i<1LL<<n_depth;i++) { zz[i]=(xx[i]*yy[i])%mod1; }
    z[1]=fft<mod1,rti1,true>(zz,n_depth);
    xx=fft<mod2,rt2,false>(x,n_depth);
    yy=fft<mod2,rt2,false>(y,n_depth);
    for (ll i=0;i<1LL<<n_depth;i++) { zz[i]=(xx[i]*yy[i])%mod2; }
    z[2]=fft<mod2,rti2,true>(zz,n_depth);

    const ll inv0=523588941, inv01=220201354;
    v_ll ret(1LL<<n_depth,0);
    for (ll i=0;i<1LL<<n_depth;i++){
        if (z[0][i]==z[1][i]&&z[0][i]==z[2][i]){
            ret[i]=z[0][i];
            if (mod!=0) ret[i]%=mod;
        }
        v_ll v(3,0);
        v[0] = z[0][i];
        v[1] = (z[1][i]-v[0]) %mod1 *inv0 %mod1;
        if (v[1]<0) v[1]+=mod1;
        v[2] = (z[2][i]-v[0]-mod0*v[1]%mod2) %mod2 *inv01 %mod2;
        if (v[2]<0) v[2]+=mod2;
        if (mod==0){
            ret[i]=v[0]+v[1]*mod0+v[2]*mod0*mod1;
            if (v[2]>=mod2/2) ret[i]-=2565855521726791681;
        }else{
            ret[i]=v[0]+v[1]*mod0%mod+v[2]*mod0%mod*mod1%mod;
            if (v[2]>=mod2/2) ret[i]-=mod0*mod1%mod*mod2%mod;
            ret[i]%=mod; if (ret[i]<0) ret[i]+=mod;
        }
    }
    return ret;
}


ll max(ll x,ll y){ return x>y?x:y;}
ll min(ll x,ll y){ return x<y?x:y;}

int main(){
    load(N,M);
    v_load(N,A);
    B.assign(100001,0);

    for (ll i=0;i<N;i++){
      B[A[i]]++;
    }

    v_ll a=convolute(B,B);
    ll remain=M;
    ans=0;

    for (ll i=200000;i>=0;i--){
      ll x=a[i];
      ans+=i*min(remain,x);
      remain-=x;
      if (remain<=0)break;
    }
    cout << ans << endl;
}




Measured memory_bytes: 17400