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 Fortran (GNU Fortran 9.2.1) (judge verdict: Time Limit Exceeded)

module mod_fft
  implicit none
  integer, parameter :: intkind = 8, realkind = 16, cmpkind = 16
  real(realkind), parameter :: pi = acos(-1.0_realkind), dpi = 2.0_realkind * pi
contains
  function convolve(a, na, b, nb) result(res)
    integer, intent(in) :: na, nb
    integer(intkind), intent(in) :: a(0:na), b(0:nb)
    integer :: p, i
    integer(intkind) :: res(0:na + nb)
    complex(cmpkind), allocatable :: fa(:), fb(:), f(:)
    p = find_pow2(na + nb + 1)
    allocate(fa(p), fb(p), f(p))
    call init(a, na, fa, p)
    call dft(fa, p)
    call init(b, nb, fb, p)
    call dft(fb, p)
    f = fa * fb
    call dft(f, p, .true.)
    res = nint(real(f(1:na + nb + 1), realkind), intkind)
  end
  integer function find_pow2(n) result(res)
    integer, intent(in) :: n
    res = n - 1
    res = or(res, rshift(res, 1))
    res = or(res, rshift(res, 2))
    res = or(res, rshift(res, 4))
    res = or(res, rshift(res, 8))
    res = or(res, rshift(res, 16))
    res = res + 1
  end
  subroutine init(a, n, f, p)
    integer, intent(in) :: n, p
    integer(intkind), intent(in) :: a(0:n)
    complex(cmpkind), intent(out) :: f(p)
    integer :: i
    f(1:n + 1) = cmplx(real(a(0:n), realkind), 0.0_realkind, cmpkind)
    f(n + 2:p) = cmplx(0.0_realkind, 0.0_realkind, cmpkind)
  end
  subroutine dft(f, p, inverse)
    integer, intent(in) :: p
    complex(cmpkind), intent(inout) :: f(p)
    logical, optional, intent(in) :: inverse
    logical :: inv
    inv = merge(inverse, .false., present(inverse))
    call fftdft(f, p, inv)
    if (inv) f = f / real(p, realkind)
  end
  recursive subroutine fftdft(f, p, inverse)
    integer, intent(in) :: p
    complex(cmpkind), intent(inout) :: f(p)
    logical, intent(in) :: inverse
    real(realkind) :: theta
    complex(cmpkind) :: f1(p / 2), f2(p / 2), z, pz
    integer :: i
    if (p == 1) return
    f1 = f(1:p:2)
    call fftdft(f1, p / 2, inverse)
    f2 = f(2:p:2)
    call fftdft(f2, p / 2, inverse)
    theta = merge(-1.0_realkind, 1.0_realkind, inverse) * dpi / real(p, realkind)
    z = exp(cmplx(0.0_realkind, theta, cmpkind))
    pz = cmplx(1.0_realkind, 0.0_realkind, cmpkind)
    do i = 1, p / 2
      f(i) = f1(i) + pz * f2(i)
      f(i + p / 2) = f1(i) - pz * f2(i)
      pz = pz * z
    end do
  end
end module mod_fft
program handshake
  use mod_fft
  implicit none
  integer :: n, i, maxa
  integer, dimension(100000) :: a
  integer(8) :: m, cnt = 0, x = 0
  integer(intkind), dimension(0:100000) :: p = 0, q = 0
  integer(intkind), dimension(0:200000) :: c = 0
  read(*,*) n, m
  read(*,*) a(1:n)
  maxa = maxval(a(1:n))
  do i = 1, n
    p(a(i)) = p(a(i)) + 1
  end do
  q = p
  c(0:2 * maxa) = convolve(p, maxa, q, maxa)
  do i = 2 * maxa, 0, -1
    if (c(i) + cnt >= m) then
      x = x + (m - cnt) * i
      exit
    else
      x = x + c(i) * i
      cnt = cnt + c(i)
    end if
  end do
  write(*,'(i0)') x
end program handshake