Problem:
Score : 400 points

Problem Statement

Takahashi is going to buy N items one by one.

The price of the i-th item he buys is A_i yen (the currency of Japan).

He has M discount tickets, and he can use any number of them when buying an item.

If Y tickets are used when buying an item priced X yen, he can get the item for \frac{X}{2^Y} (rounded down to the nearest integer) yen.

What is the minimum amount of money required to buy all the items?

Constraints

All values in input are integers.

1 \leq N, M \leq 10^5

1 \leq A_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N M
A_1 A_2 ... A_N

Output

Print the minimum amount of money required to buy all the items.

Sample Input 1

3 3
2 13 8

Sample Output 1

9

We can buy all the items for 9 yen, as follows:

Buy the 1-st item for 2 yen without tickets.

Buy the 2-nd item for 3 yen with 2 tickets.

Buy the 3-rd item for 4 yen with 1 ticket.

Sample Input 2

4 4
1 9 3 5

Sample Output 2

6

Sample Input 3

1 100000
1000000000

Sample Output 3

0

We can buy the item priced 1000000000 yen for 0 yen with 100000 tickets.

Sample Input 4

10 1
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000

Sample Output 4

9500000000

Solution in LuaJIT (2.0.4) (judge verdict: Accepted)

local floor = math.floor
-- heap
local function Heap(upper_func)
    local floor = math.floor
    local a = {}
    local upper = function(k1, k2)
        --assert(k1 < k2)
        if k1 == 0 then
            return false
        else
            return upper_func(a[k1], a[k2])
        end
    end

    local lower = function(k1, k2)
        return not upper(k1, k2)
    end

    local function count()
        return #a
    end

    local function _swap(k1, k2)
        local old_k1 = a[k1]
        a[k1] = a[k2]
        a[k2] = old_k1
    end

    local function upheap(newk)
        local ku = floor(newk / 2)
        local k = newk
        while ku > 0 and lower(ku, k) do
            _swap(ku, k)
            k = floor(k/2)
            ku = floor(ku/2)
        end
    end
    
    local insert = table.insert
    local function insertq(e)
        insert(a, e)
        upheap(#a)
    end
    
    local function downheap(newk)
        local k = newk
        while k <= floor(#a/2) do
            local kdl = k*2
            local kdr = kdl + 1
            local kd
            if kdr <= #a and lower(kdl, kdr) then
                kd = kdr
            else
                kd = kdl
            end
            if upper(k, kd) then
                break
            end
            _swap(k, kd)
            k = kd
        end
    end
    
    local function top()
        --assert(#a >= 1)
        return a[1]
    end
    
    local remove = table.remove
    local function remove_top()
        --assert(#a >= 1)
        local v = a[1]
        _swap(1, #a)
        remove(a)
        downheap(1)
        return v
    end

    local self = {}
    self.count = count
    self.insertq = insertq
    self.top = top
    self.remove_top = remove_top
    return self
end

---
local N, M = io.read("*n", "*n")
local q = Heap(function (x,y) return x > y end)
local insertq = q.insertq
local remove_top = q.remove_top
for i=1,N do
    insertq(io.read("*n"))
end
for i=1,M do
    local top = remove_top()
    top = top / 2
    insertq(top)
end
local sum = 0
for i=1,N do
    local top = remove_top()
    sum = sum + floor(top)
end
print(sum)