# returns an arithmetic sequence sum 
# a + (a-1) + (a-2) ... +    a total of 'm' terms.
def seq(a, m):
    s = 0
    b = a
    while m > 0:
        s += b
        b -= 1
        m -= 1
    return s    


"""
Given a sequence of equal/biggest numbers 'array[i... j]' (i,j inclusive)
Use them 'subtractMe' times in a greedy fashion.
In order to keep 'array' in order, use the rightmost item first.

"""
def subtract(array, i, j, subtractMe):


    sum = 0

    #Use a multiple of (j - i + 1) times equally.
    m = subtractMe / (j - i + 1)
    for itr in range(i, j + 1):
        #use a sequence sum.
        sum += seq(array[itr], m)
        array[itr] -= m

    #Use the rest with the rightmost item first.
    #The rest <= (j - i + 2)
    rem = subtractMe % (j - i + 1)
    for itr in range(j, j - rem, -1):
        sum += array[itr]
        array[itr] -= 1
    #return i, j, sum where j is adjusted to cover the new range of eqal/biggest numbers.
    return i, j - rem, sum

def solve(array, m):
    #sort the array in a DESCENDING order
    array.sort(reverse = True)

    n = len(array)
    #assume array[0] is the single biggest element.
    i = 0
    j = 0


    #find initial 'j' where array[i..j] = biggest/equal.
    while j < n - 1:
        if array[i] != array[j+1]: break
        j += 1



    #If the entire array is one of a single element, 
    if j == n - 1:
        #calculate the ans.
        amount = min(m, (j - i + 1)*(array[j]))
        return subtract(array, i, j, amount)[2]

    #'k' points to the second biggest element.
    k = j + 1

    #initial sum.
    s = 0

    #Until we end up using all 'm' times.
    while m > 0:

        #At each turn, we can use a minimum of 'm' times or
        #the upper area of array[i..j] that's above the second biggest element, times.
        amount = min(m, (j - i + 1)*(array[j] - array[k]))

        #decrease 'm'
        m -= amount


        res = subtract(array, i, j, amount)
        #update 'j'
        j = res[1]


        #we need to extend our array[i..j].
        if array[j] == array[k]:
            j = k
            k = j + 1

        #we need to decrease our array[i..j]
        else:
            j, k = res[1], res[1] + 1

        #update 'sum'
        s += res[2]

        #if we reached the 'end' of our array. i.e. 
        #all items are 'level'. = same height
        #look no further.
        if j == n - 1:
            amount = min(m, (j - i + 1)*(array[j]))

            return s + subtract(array, i, j, amount)[2]

    return s


for _ in range(input()):
    l = raw_input().split()
    m = int(l[1])
    l = map(int, raw_input().split())
    print solve(l, m)