using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;

namespace AtCoder.ABC
{
    class QuestionB
    {
        public static void Main(string[] args)
        {
            var nm = Console.ReadLine().Split(" ").Select(x => long.Parse(x)).ToArray();
            var n = nm[0];
            var m = nm[1];

            var a = Console.ReadLine().Split(" ").Select(x => long.Parse(x)).ToArray();
            var sum = a.Sum();

            var priorityQueue = new PriorityQueue<long>();

            for(int i = 0; i < n; i++) {
                priorityQueue.Enqueue(a[i]);
            }

            for(int i = 0; i < m; i++) {
                var max = priorityQueue.Dequeue();
                var temp = max / 2;
                sum -= max - temp;
                priorityQueue.Enqueue(temp);
            }

            Console.WriteLine(sum);
        }

        public class PriorityQueue<T>
        {
            private readonly List<T> data_ = new List<T>();
            private readonly IComparer<T> comparer_;
            private readonly bool isDescending_;

            public PriorityQueue(IComparer<T> comparer, bool isDescending = true)
            {
                comparer_ = comparer;
                isDescending_ = isDescending;
            }

            public PriorityQueue(Comparison<T> comparison, bool isDescending = true)
                : this(Comparer<T>.Create(comparison), isDescending)
            {
            }

            public PriorityQueue(bool isDescending = true)
                : this(Comparer<T>.Default, isDescending)
            {
            }

            public void Enqueue(T item)
            {
                data_.Add(item);
                var childIndex = data_.Count - 1;
                while (childIndex > 0) {
                    var parentIndex = (childIndex - 1) / 2;

                    if (Compare(data_[childIndex], data_[parentIndex]) >= 0) {
                        break;
                    }

                    Swap(childIndex, parentIndex);
                    childIndex = parentIndex;
                }
            }

            public T Dequeue()
            {
                var lastIndex = data_.Count - 1;
                var firstItem = data_[0];
                data_[0] = data_[lastIndex];
                data_.RemoveAt(lastIndex--);
                var parentIndex = 0;
                while (true) {
                    var childIndex = parentIndex * 2 + 1;

                    if (childIndex > lastIndex) {
                        break;
                    }

                    var rightChild = childIndex + 1;

                    if (rightChild <= lastIndex && Compare(data_[rightChild], data_[childIndex]) < 0) {
                        childIndex = rightChild;
                    }

                    if (Compare(data_[parentIndex], data_[childIndex]) <= 0) {
                        break;
                    }

                    Swap(parentIndex, childIndex);
                    parentIndex = childIndex;
                }
                return firstItem;
            }

            public T Peek()
            {
                return data_[0];
            }

            private void Swap(int a, int b)
            {
                var tmp = data_[a];
                data_[a] = data_[b];
                data_[b] = tmp;
            }

            private int Compare(T a, T b)
            {
                return isDescending_ ? comparer_.Compare(b, a) : comparer_.Compare(a, b);
            }

            public int Count => data_.Count;
        }
    }
}


Measured memory_bytes: 40448