Problem:
Score : 500 points

Problem Statement

Takahashi has come to a party as a special guest.
There are N ordinary guests at the party. The i-th ordinary guest has a power of A_i.

Takahashi has decided to perform M handshakes to increase the happiness of the party (let the current happiness be 0).
A handshake will be performed as follows:

Takahashi chooses one (ordinary) guest x for his left hand and another guest y for his right hand (x and y can be the same).

Then, he shakes the left hand of Guest x and the right hand of Guest y simultaneously to increase the happiness by A_x+A_y.

However, Takahashi should not perform the same handshake more than once. Formally, the following condition must hold:

Assume that, in the k-th handshake, Takahashi shakes the left hand of Guest x_k and the right hand of Guest y_k. Then, there is no pair p, q (1 \leq p < q \leq M) such that (x_p,y_p)=(x_q,y_q).

What is the maximum possible happiness after M handshakes?

Constraints

1 \leq N \leq 10^5

1 \leq M \leq N^2

1 \leq A_i \leq 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_N

Output

Print the maximum possible happiness after M handshakes.

Sample Input 1

5 3
10 14 19 34 33

Sample Output 1

202

Let us say that Takahashi performs the following handshakes:

In the first handshake, Takahashi shakes the left hand of Guest 4 and the right hand of Guest 4.

In the second handshake, Takahashi shakes the left hand of Guest 4 and the right hand of Guest 5.

In the third handshake, Takahashi shakes the left hand of Guest 5 and the right hand of Guest 4.

Then, we will have the happiness of (34+34)+(34+33)+(33+34)=202.

We cannot achieve the happiness of 203 or greater, so the answer is 202.

Sample Input 2

9 14
1 3 5 110 24 21 34 5 3

Sample Output 2

1837

Sample Input 3

9 73
67597 52981 5828 66249 75177 64141 40773 79105 16076

Sample Output 3

8128170

Solution in Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::cmp::Ordering;
use std::io::{self, BufRead};
use std::collections::BinaryHeap;

#[derive(Debug)]
struct Pair(usize, usize, usize);

impl Ord for Pair {
  fn cmp(&self, other: &Self) -> Ordering {
    self.0.cmp(&other.0)
  }
}

impl PartialOrd for Pair {
  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    Some(self.0.cmp(&other.0))
  }
}

impl PartialEq for Pair {
  fn eq(&self, other: &Self) -> bool {
    self.0 == other.0
  }
}

impl Eq for Pair {}


fn main() {
  let stdin = io::stdin();
  let mut lines = stdin.lock().lines();
  let line = lines.next().unwrap().unwrap();
  let vs: Vec<usize> = line.split(' ').map(|x| x.parse().unwrap()).collect();
  let n = vs[0];
  let mut m = vs[1];
  let line = lines.next().unwrap().unwrap();
  let mut xs: Vec<usize> = line.split(' ').map(|x| x.parse().unwrap()).collect();
  xs.sort_by(|a, b| b.cmp(&a));
  // println!("{:?}", xs);
  let mut buf: BinaryHeap<Pair> = BinaryHeap::new();
  let mut score = 0;
  buf.push(Pair(xs[0]*2, 0, 0));
  while let Some(Pair(p, x, y)) = buf.pop() {
    if m == 0 {
      break;
    }
    score += p;
    m -= 1;
    if x < n-1 && y == 0 {
      buf.push(Pair(xs[x+1] + xs[0], x+1, 0));
    }
    if y < n-1 {
      buf.push(Pair(xs[x] + xs[y+1], x, y+1));
    }
  }
  println!("{}", score);
}