There are some rabbits in Singapore Zoo. To feed them, Zookeeper bought n carrots with lengths a_1, a_2, a_3, …, a_n. However, rabbits are very fertile and multiply very quickly. Zookeeper now has k rabbits and does not have enough carrots to feed all of them. To solve this problem, Zookeeper decided to cut the carrots into k pieces. For some reason, all resulting carrot lengths must be positive integers.

Big carrots are very difficult for rabbits to handle and eat, so the time needed to eat a carrot of size x is x^2.

Help Zookeeper split his carrots while minimizing the sum of time taken for rabbits to eat the carrots.

Input

The first line contains two integers n and k (1 ≤ n ≤ k ≤ 10^5): the initial number of carrots and the number of rabbits.

The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^6): lengths of carrots.

It is guaranteed that the sum of a_i is at least k.

Output

Output one integer: the minimum sum of time taken for rabbits to eat carrots.

Examples

Input


3 6
5 3 1


Output


15


Input


1 4
19


Output


91

Note

For the first test, the optimal sizes of carrots are \{1,1,1,2,2,2\}. The time taken is 1^2+1^2+1^2+2^2+2^2+2^2=15

For the second test, the optimal sizes of carrots are \{4,5,5,5\}. The time taken is 4^2+5^2+5^2+5^2=91.
# by the authority of GOD     author: manhar singh sachdev #
 
import os,sys
from io import BytesIO, IOBase
from heapq import *
 
class Node:
    def __init__(self,ori,piece):
        self.ori = ori
        self.piece = piece
        self.inc = 0
    def __lt__(self, other):
        return self.inc > other.inc
 
def main():
    n,k = map(int,input().split())
    x = list(map(lambda y:Node(int(y),1),input().split()))
    for i in x:
        xx,yy = divmod(i.ori,i.piece)
        xx1,yy1 = divmod(i.ori,i.piece+1)
        aa = i.piece*(xx**2)+yy*(2*xx+1)
        bb = (i.piece+1)*(xx1**2)+yy1*(2*xx1+1)
        i.inc = aa-bb
    heapify(x)
    for _ in range(k-n):
        r = heappop(x)
        r.piece += 1
        xx,yy = divmod(r.ori,r.piece)
        aa = r.piece*(xx**2)+yy*(2*xx+1)
        xx1,yy1 = divmod(r.ori,r.piece+1)
        bb = (r.piece+1)*(xx1**2)+yy1*(2*xx1+1)
        r.inc = aa-bb
        heappush(x,r)
    ti = 0
    for j in x:
        rr,rr1 = divmod(j.ori,j.piece)
        ti += j.piece*rr*rr+(2*rr+1)*rr1
    print(ti)
 
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
 
if __name__ == '__main__':
    main()