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

namespace SolutionCS
{
    class Program
    {
        // PriorityQueue
        // コンストラクタの第2引数にfalseを指定すると降順、true指定または何も指定しないと昇順
        public class PriorityQueue
        {
            int[] heap;
            int count = 0;
            bool ascend = true;

            public PriorityQueue(int maxSize, bool ascend = true)
            {
                heap = new int[maxSize];
                count = 0;
                this.ascend = ascend;
            }

            private int Compare(int e0, int e1)
            {
                if (!ascend)
                {
                    return e0.CompareTo(e1);
                }

                return e1.CompareTo(e0);
            }

            public void Push(int elem)
            {
                // 要素をPushするインデックス(枝の末尾部分)
                int i = count;

                // 要素数を増やす
                count++;

                // 親(i=0)に向かってたどる
                while (i > 0)
                {
                    // 親のインデックス
                    int p = (i - 1) / 2;

                    // elemのほうが大きいか同一の場合、Pushするインデックス確定
                    if (Compare(heap[p], elem) <= 0)
                    {
                        break;
                    }

                    // 親→子にコピーして再度親との比較を行う
                    heap[i] = heap[p];
                    i = p;
                }

                // 要素を決まったインデックスに入れる
                heap[i] = elem;
            }

            public int Pop()
            {
                // 要素なしの場合、Exception
                if (count == 0)
                {
                    throw new InvalidOperationException();
                }

                // 要素数減らす
                count--;

                // 返す要素を保存
                int result = heap[0];

                // 一番末端の要素(これを親から比較して配列に配置する)
                int x = heap[count];

                // 親から末尾に向かって子→親入れ替えを行う
                int i = 0;
                while (i * 2 + 1 < count)
                {
                    int l = i * 2 + 1;      // 子の左枝のインデックス
                    int r = i * 2 + 2;      // 子の右枝のインデックス

                    // 右が範囲外ではない、右のほうが小さいか検証
                    if (r < count && Compare(heap[r], heap[l]) < 0)
                    {
                        // 右のほうが小さい場合、上に上がっていくのは右のインデックス
                        l = r;
                    }

                    // x(配列の一番最後の要素)と比べて、大きければおわり
                    if (Compare(heap[l], x) >= 0)
                    {
                        break;
                    }

                    // 一個親側に繰り上げ
                    heap[i] = heap[l];

                    // 処理した枝のインデックスを与え、再度入れ替え
                    i = l;
                }

                // 一番末尾の要素を新たに保存
                heap[i] = x;

                // 最初に保存していた結果を返す
                return result;
            }

            public long Sum()
            {
                long s = 0;

                for (int i = 0; i < count; i++)
                {
                    s += heap[i];
                }

                return s;
            }

            public int Count { get { return count; } }
            public int Peek { get { return heap[0]; } }
        }

        static void Main(string[] args)
        {
            string[] s = Console.ReadLine().Split(' ');
            int N = int.Parse(s[0]);
            int M = int.Parse(s[1]);

            PriorityQueue pq = new PriorityQueue(N, true);

            s = Console.ReadLine().Split(' ');
            for (int i = 0; i < N; i++)
            {
                pq.Push(int.Parse(s[i]));
            }

            for (int i = 0; i < M; i++)
            {
                int v = pq.Pop();

                v /= 2;
                pq.Push(v);
            }

            Console.WriteLine(pq.Sum());
        }
    }
}



Measured memory_bytes: 27104