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)
        {
            AC138C();
        }

        static void AC138C()
        {
            //https://atcoder.jp/contests/abc138/tasks

            var n = int.Parse(Console.ReadLine());
            var listV = Console.ReadLine().Split().Select(int.Parse).ToArray();

            PriorityQueue<double> p = new PriorityQueue<double>(n, false);

            foreach(var v in listV)
            {
                p.Push(v);
            }

            for (int i = 0; i < n -1; i++)
            {
                //最小値を読み出し
                var min1 = p.Top;
                //最小値を削除
                p.Pop();
                //次の最小値を読み出し
                var min2 = p.Top;
                //削除
                p.Pop();

                //足して2で割った結果をキューに突っ込む
                p.Push((min1 + min2) / 2);
            }

            Console.WriteLine(p.Top);
            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;
        public readonly bool Greater;   //trueの場合は最大値を取り出せる、falseの場合は最小値を取り出せる

        #endregion
        #region 初期化

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

        #endregion
        #region ヒープ操作

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

            while (n != 0)
            {
                int i = (n - 1) / 2;
                var c = array[n].CompareTo(array[i]);
                if(!this.Greater)
                {
                    c = -c;
                }
                if (c > 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)
        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; )
            {
                var c1 = array[j].CompareTo(array[j + 1]);
                if(!Greater)
                {
                    c1 = -c1;
                }
                if ((j != n - 1) && (c1 < 0))
                    j++;
                var c2 = array[i].CompareTo(array[j]);
                if(!Greater)
                {
                    c2 = -c2;
                }
                if (c2 < 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: 13396