using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ProCon
{
    class Program
    {
        static void Main(string[] args)
        {
            AC141D();
        }

        static void AC141D()
        {
            //https://atcoder.jp/contests/abc141/tasks
            var list = Console.ReadLine().Split().Select(int.Parse).ToArray();

            int n = list[0]; //品物の数
            int m = list[1]; //割引券の枚数

            var products = Console.ReadLine().Split().Select(long.Parse).OrderBy(x => x).ToArray();
            var q = new PriorityQueue<long>(n);
            foreach(var p in products)
            {
                q.Push(p);
            }

            long w = 0;

            for(int i = 0; i < m; i++)
            {
                w = q.Top / 2;
                q.Pop();
                q.Push(w);
            }

            int c = q.Count;
            long sum = 0;

            for(int i = 0; i < c ; i++)
            {
                sum += q.Top;
                q.Pop();
            }

            Console.WriteLine(sum);
            Console.ReadKey();
        }

    }
  　public class ArrayList<T> : IEnumerable<T>
    {
        #region フィールド
        T[] data;
        int count;
        #endregion

        #region 初期化
        public ArrayList() : this(256) { }
        /// <summary>
        /// 初期最大容量を指定して初期化。
        /// </summary>
        /// <param name="capacity">初期最大容量</param>
        public ArrayList(int capacity)
        {
            this.data = new T[capacity];
            this.count = 0;
        }
        #endregion

        #region プロパティ
        /// <summary>
        /// 格納されている要素数。
        /// </summary>
        public int Count
        {
            get { return this.count; }
        }

        /// <summary>
        /// i 番目の要素を読み書き。
        /// </summary>
        /// <param name="i">読み書き位置</param>
        /// <returns>読み出した要素</returns>
        public T this[int i]
        {
            get { return this.data[i]; }
            set { this.data[i] = value; }
        }
        #endregion

        #region 挿入・削除
        /// <summary>
        /// 配列を確保しなおす。
        /// </summary>
        /// <remarks>
        /// 配列長は2倍ずつ拡張していきます。
        /// </remarks>
        void Extend()
        {
            T[] data = new T[this.data.Length * 2];
            for (int i = 0; i < this.data.Length; ++i) data[i] = this.data[i];
            this.data = data;
        }

        /// <summary>
        /// i 番目の位置に新しい要素を追加。
        /// </summary>
        /// <param name="i">追加位置</param>
        /// <param name="elem">追加する要素</param>
        public void Insert(int i, T elem)
        {
            if (this.count >= this.data.Length)
                this.Extend();
            for (int n = this.count; n > i; --n)
            {
                this.data[n] = this.data[n - 1];
            }
            this.data[i] = elem;
            ++this.count;
        }

        /// <summary>
        /// 末尾に新しい要素を追加。
        /// </summary>
        /// <param name="elem">追加する要素</param>
        public void InsertLast(T elem)
        {
            if (this.count >= this.data.Length)
                this.Extend();
            this.data[this.count] = elem;
            ++this.count;
        }

        /// <summary>
        /// i 番目の要素を削除。
        /// </summary>
        /// <param name="i">削除位置</param>
        public void Erase(int i)
        {
            for (int n = i; n < this.count - 1; ++n)
            {
                this.data[n] = this.data[n + 1];
            }
            --this.count;
        }

        /// <summary>
        /// 末尾の要素を削除。
        /// </summary>
        public void EraseLast()
        {
            --this.count;
        }
        #endregion

        #region IEnumerable<T> メンバ
        public IEnumerator<T> GetEnumerator()
        {
            for (int i = 0; i < this.count; ++i)
                yield return this.data[i];
        }

        System.Collections.IEnumerator
          System.Collections.IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }
        #endregion
    }
    
  public class PriorityQueue<T> where T : IComparable<T>
    {
        #region フィールド

        ArrayList<T> buffer;

        #endregion
        #region 初期化

        public PriorityQueue() { this.buffer = new ArrayList<T>(); }
        public PriorityQueue(int capacity) { this.buffer = new ArrayList<T>(capacity); }

        #endregion
        #region ヒープ操作

        /// <summary>
        /// ヒープ化されている配列リストに新しい要素を追加する。
        /// </summary>
        /// <param name="array">対象の配列リスト</param>
        static void PushHeap(ArrayList<T> array, T elem)
        {
            int n = array.Count;
            array.InsertLast(elem);

            while (n != 0)
            {
                int i = (n - 1) / 2;
                if (array[n].CompareTo(array[i]) > 0)
                {
                    T tmp = array[n]; array[n] = array[i]; array[i] = tmp;
                }
                n = i;
            }
        }

        /// <summary>
        /// ヒープから最大値を削除する。
        /// </summary>
        /// <param name="array">対象の配列リスト</param>
        static void PopHeap(ArrayList<T> array)
        {
            int n = array.Count - 1;
            array[0] = array[n];
            array.EraseLast();

            for (int i = 0, j; (j = 2 * i + 1) < n; )
            {
                if ((j != n - 1) && (array[j].CompareTo(array[j + 1]) < 0))
                    j++;
                if (array[i].CompareTo(array[j]) < 0)
                {
                    T tmp = array[j]; array[j] = array[i]; array[i] = tmp;
                }
                i = j;
            }
        }

        #endregion
        #region 要素の挿入・削除

        /// <summary>
        /// 要素のプッシュ。
        /// </summary>
        /// <param name="elem">挿入したい要素</param>
        public void Push(T elem)
        {
            PushHeap(this.buffer, elem);
        }

        /// <summary>
        /// 要素を1つポップ。
        /// </summary>
        /// <remarks>
        /// 今回の実装では、先頭要素の読み出しと削除は別に行う。
        /// この Pop では削除のみ。
        /// 読み出しには Top プロパティを使う。
        /// </remarks>
        public void Pop()
        {
            PopHeap(this.buffer);
        }

        /// <summary>
        /// 先頭要素の読み出し。
        /// </summary>
        public T Top
        {
            get { return this.buffer[0]; }
        }

        public int Count
        {
            get { return this.buffer.Count; }
        }

        #endregion

    }
}


Measured memory_bytes: 30172