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.
// package com.company;



import java.io.*;
import java.util.*;

public class Main <E> {

    public static void main(String[] args) {
        Main main = new Main();
        main.solve();
    }

    private class Option {
        public long ans;
        public int i;
        public Option(int i, long ans) {
            this.i = i;
//            this.chunks = chunks;
            this.ans = ans;
        }
    }

    long MODULE = 1000_000_000+7;
    public void solve() {

        Scanner in = null;
        PrintWriter out = null;
        try {
            in = new Scanner(new File("input.txt"));
            out = new PrintWriter(new File("output.txt"));
//                throw new FileNotFoundException();
        }
        catch (FileNotFoundException e) {
            in = new Scanner(System.in);
            out = new PrintWriter(System.out);
        }

        int t = 1;//in.nextInt();

        for (int ti = 0; ti < t; ti++) {
            int n = in.nextInt();
            int k = in.nextInt();
            int[] a = new int[n];

            for (int i = 0; i < n; i++) {
                a[i] =in.nextInt();
            }
            int cuts = k - n;

            int[] b = new int[n];
            for (int i = 0; i < n; i++) {
                b[i] = 1;
            }

            long curans = 0;
            for (int i = 0; i < n; i++) {
                curans += ((long)a[i]) * ((long)a[i]);
            }

            PriorityQueue<Option> curanses = new PriorityQueue<>((o1, o2) -> Long.compare(o2.ans, o1.ans));
            for (int i = 0; i < n; i++) {
                curanses.add(new Option(i, findans(a[i], b[i]) - findans(a[i], b[i] + 1)));
            }

//            long[] curanses = new long[n];
            while (cuts > 0) {
                Option o = curanses.poll();
                curans = curans - o.ans;
                curanses.add(new Option(o.i, findans(a[o.i], b[o.i] + 1) - findans(a[o.i], b[o.i] + 2)));
                b[o.i]++;
                cuts--;
            }


            out.println(curans);


        }


        out.flush();

        out.close();
    }

    public long findans(int len, int chunks) {
        long ans = 0;
        int partlen = len / chunks;
        int partmon = len % chunks;
        ans += ((long)partlen + 1) * (partlen + 1) * (partmon);
        ans += (long)partlen * partlen * (chunks - partmon);
        return ans;
    }

}
