@file:Suppress("DuplicatedCode")

import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.util.NoSuchElementException

fun main(args: Array<String>) {
    PrintWriter(System.out).use { out ->
        D.solve(D.FastScanner(), out)
        out.flush()
    }
}

private fun D.solve(sc: D.FastScanner, out: PrintWriter) {
    val n = sc.nextInt()
    val m = sc.nextInt()
    val heap = D.IntHeap(n, D.IntHeap.Comparator.MAX)

    repeat(n) {
        heap.add(sc.nextInt())
    }

    repeat(m) {
        val root = heap.pop()
        heap.add(root / 2)
    }

    var sum = 0L
    heap.toIterator().forEach {
        sum += it
    }

    println(sum)
}

@Suppress("MemberVisibilityCanBePrivate")
private object D {
    private const val zeroCode = '0'.toInt()
    private const val nineCode = '9'.toInt()

    class FastScanner {
        private val `in`: InputStream = System.`in`
        private val buffer = ByteArray(1024)
        private var ptr = 0
        private var buflen = 0
        private fun hasNextByte(): Boolean {
            if (ptr < buflen) {
                return true
            } else {
                ptr = 0
                try {
                    buflen = `in`.read(buffer)
                } catch (e: IOException) {
                    e.printStackTrace()
                }
                if (buflen <= 0) {
                    return false
                }
            }
            return true
        }

        private fun readByte(): Int {
            return if (hasNextByte()) buffer[ptr++].toInt() else -1
        }

        operator fun hasNext(): Boolean {
            while (hasNextByte() && !isPrintableChar(buffer[ptr].toInt())) ptr++
            return hasNextByte()
        }

        operator fun next(): String {
            if (!hasNext()) throw NoSuchElementException()

            return buildString {
                var b = readByte()

                while (isPrintableChar(b)) {
                    appendCodePoint(b)
                    b = readByte()
                }
            }
        }

        fun nextLong(): Long {
            if (!hasNext()) throw NoSuchElementException()
            var n: Long = 0
            var minus = false
            var b = readByte()

            if (b == '-'.toInt()) {
                minus = true
                b = readByte()
            }

            if (b !in zeroCode..nineCode) {
                throw NumberFormatException()
            }

            while (true) {
                if (b in zeroCode..nineCode) {
                    n *= 10
                    n += b - zeroCode.toLong()
                } else if (b == -1 || !isPrintableChar(b)) {
                    return if (minus) -n else n
                } else {
                    throw NumberFormatException()
                }

                b = readByte()
            }
        }

        fun nextInt(): Int {
            val nl = nextLong()
            if (nl < Int.MIN_VALUE || nl > Int.MAX_VALUE) throw NumberFormatException()
            return nl.toInt()
        }

        fun nextDouble(): Double {
            return next().toDouble()
        }

        fun readIntArray(n: Int): IntArray {
            val arr = IntArray(n)

            for (i in 0 until n) {
                arr[i] = nextInt()
            }

            return arr
        }

        fun readBigInt(capacity: Int): IntArray {
            if (!hasNext()) throw NoSuchElementException()

            val arr = IntArray(capacity)
            var len = 0
            arr[0] = readByte() - zeroCode
            while (arr[len] in 0..9) {
                len++
                arr[len] = readByte() - zeroCode
            }

            return arr.sliceArray(0 until len)
        }

        companion object {
            private fun isPrintableChar(c: Int): Boolean {
                return c in 33..126
            }
        }
    }

    class IntHeap(capacity: Int, private val comp: Comparator) {
        enum class Comparator {
            MIN, MAX
        }

        private val array = IntArray(capacity + 1)

        var firstEmptyIndex: Int
            get() = array[0]
            set(value) {
                array[0] = value
            }

        val size: Int
            get() = firstEmptyIndex - 1

        var root: Int
            get() = array[1]
            private set(value) {
                array[1] = value
            }

        init {
            firstEmptyIndex = 1
        }

        private inline fun isPrior(e1: Int, e2: Int): Boolean {
            return if (comp == Comparator.MIN) {
                e1 < e2
            } else e1 > e2
        }

        fun add(elem: Int) {
            array[firstEmptyIndex] = elem
            upHeap(firstEmptyIndex++)
        }

        fun pop(): Int {
            val root = root
            this.root = array[--firstEmptyIndex]
            downRoot()
            return root
        }

        private fun upHeap(index: Int) {
            var current = index

            while (current > 1) {
                val parent = current / 2

                if(isPrior(array[current], array[parent])) {
                    val tmp = array[parent]
                    array[parent] = array[current]
                    array[current] = tmp

                    current = parent
                } else break
            }
        }

        private fun downRoot() {
            var current = 1
            var child = 2

            while (child < firstEmptyIndex) {
                if (child + 1 < firstEmptyIndex && isPrior(array[child + 1], array[child])) {
                    child++
                }

                if (isPrior(array[child], array[current])) {
                    val tmp = array[current]
                    array[current] = array[child]
                    array[child] = tmp

                    current = child
                    child *= 2
                } else break
            }
        }

        fun toIterator(): IntIterator = object: IntIterator() {
            private var current = 1

            override fun hasNext(): Boolean = current < firstEmptyIndex

            override fun nextInt(): Int {
                return array[current++]
            }
        }
    }
}
