#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define repi(i, a, b) for(int i=(a); i>(b); i--)
#define db(x) (cerr << #x << ": " << (x) << '\n')
#define sync ios_base::sync_with_stdio(false), cin.tie(NULL)
#define cps CLOCKS_PER_SEC
#define tests(t) int t; cin >> t; while(t--)
#define iceil(n, x) (((n) + (x) - 1) / (x))
#define ll long long
#define gcd __gcd
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define sz size()
#define all(v) (v).begin(), (v).end()
#define uni(v) sort(all(v)), (v).erase(unique(all(v)), (v).end())
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define fi first
#define se second
#define mt make_tuple
#define pqueue priority_queue
#define bitcount(x) __builtin_popcount(x)
#define PI acos(-1.0)
#define EPS 1e-9
#define mod 1000000007
using namespace std;

#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
    cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
    const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}

template<typename T1, typename T2>
ostream& operator << (ostream& os, const pair<T1, T2>& p) { return os << '(' << p.fi << ", " << p.se << ')'; }

template<typename T>
void printv(const T& v) { for(auto i : v) cerr << i << ' '; cerr << '\n'; }

template<typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;

template<typename T>
using maxpq = priority_queue<T>;

//All indexing is 0-based
using namespace __gnu_pbds;
template<class key, class cmp = std::less<key>>
using ordered_set = tree<key, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
//methods: find_by_order(k); & order_of_key(k);
//To make it an ordered_multiset, use pairs of (value, time_of_insertion)
//to distinguish values which are similar

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;

//Returns no. of values x for which ceil(n / x) == y (y must be > 1).
inline ll CC(ll n, ll y) { return iceil(n, y-1) - iceil(n, y); }

//Returns no. of values x for which floor(n / x) == y
inline ll FF(ll n, ll y) { return n / y - n / (y+1); }

//a and b are assumed to be taken modulo p
inline int add(int a, int b, int p = mod){ int c = a + b; if(c >= p) c -= p; return c; }
inline int sub(int a, int b, int p = mod){ int c = a - b; if(c < 0) c += p; return c; }
inline int mul(int a, int b, int p = mod){ return (a * 1ll * b) % p; }

#define N 100005
#define int ll
// #define trace(...) 42

//typedef complex<double> base;

struct base {
    double x, y;
    double &re, &im;
    base(double _x = 0, double _y = 0)
    :x(_x), y(_y), re(x), im(y){}
    base(const base& b) 
    :x(b.x), y(b.y), re(x), im(y){}
    
    base conj() { return base(x, -y); }
    base operator = (double d) { x = d, y = 0; return *this; }
    base operator = (const base& b) { x = b.x, y = b.y; return *this; }
    base operator + (const base& b) { return base(x + b.x, y + b.y); }
    base operator - (const base& b) { return base(x - b.x, y - b.y); }
    base operator * (const base& b) { return base(x*b.x - y*b.y, y*b.x + x*b.y); }
    base operator / (double d) { return base(x/d, y/d); }
    base operator += (const base& b) { x += b.x, y += b.y; return *this; }
    base operator -= (const base& b) { x -= b.x, y -= b.y; return *this; }
    base operator *= (const base& b) { double p, q; p = x*b.x - y*b.y, q = y*b.x + x*b.y; x=p, y=q; return *this; }
    base operator /= (double d) { x /= d, y /= d; return *this; }
};

vi order; //order stores the bit reversal permutations

void fft(vector<base> &a,bool invert)
{
    int n = a.size();
    for(int i = 0;i < n;i++)
        if (order[i] < i)
            swap(a[i],a[order[i]]);
    for (int len = 2; len <= n; len <<= 1)
    {
        double ang = 2 * PI / len * (invert ? -1 : 1);
        base wlen (cos(ang), sin(ang));
        int half = len >> 1;
        vector<base> w(half);
        base w0(1);
        //Precompute w's
        for(int i = 0; i < half; i++)
            w[i] = w0,w0 *= wlen;
        for (int i = 0; i < n; i += len)
        {
            for (int j = 0; j < half; j++)
            {
                base u = a[i + j];
                base v = a[i + j + half] * w[j];
                a[i + j] = u + v;
                a[i + j + half] = u - v;
            }
        }
    }
    if (invert)
        for (int i = 0; i < n; i++)
            a[i] /= n;
}
 
void precalc(int n, int L)
{
    order.resize(n);
    for(int i = 0; i < n; i++)
    {
        int res = 0;
        for(int j = 0;j < L;j++)
            if (i & (1<<j))
                res |= 1<<(L - j - 1);
        order[i] = res;
    }
}
 
vi multiply(const vi& a, const vi& b)
{
    vector<base> fa(a.begin(),a.end()), fb(b.begin(),b.end());
    int n = 1; 
    int L = 0;
    while(a.size() + b.size() - 1 > n)
        n <<= 1, L++;
    //n == 2 ** L
    fa.resize(n);
    fb.resize(n);
    precalc(n, L);
    fft(fa,false);
    fft(fb,false);
    for(int i = 0;i < n;i++)
        fa[i] *= fb[i];
    fft(fa,true);
 
    vi res(n);
    for(int i = 0;i < n;i++)
    {
        res[i] = (int)(fa[i].re + 0.5);
//        res[i] = min(res[i],1);
    }
    
    /* Uncomment following 2 lines to prune the trailing 0s from the polynomial.*/
   while(res.size() > 1 && res.back() == 0)
       res.pop_back();
    return res;
}

main()
{   
    #ifdef CP
        freopen("/home/tarun/Desktop/input.txt", "r", stdin);
     // freopen("/home/tarun/Desktop/output.txt", "w", stdout);
    #endif
    sync;
    clock_t clk = clock();
    cerr << "I will return...\n";

    vi a(N);

    int n, m; cin >> n >> m;
    rep(i, 0, n) {
        int x; cin >> x; ++a[x];
    }

    auto b = multiply(a, a);

    int ans = 0;

    for(int i = b.size()-1; m && i; i--) {
        int x = b[i];

        ans += min(m, x) * i;
        m -= min(m, x);
    }

    cout << ans << '\n';

    cerr << "...don't you ever hang your head.\n";
    cerr << "Time (in ms): " << (double)(clock() - clk) * 1000.0 / cps << '\n';
}

//Compile using:
//g++ -o filename.exe --std=c++11 filename.cpp
//Use -D CP for defining a macro CP in the local environment




Measured memory_bytes: 25872