import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class Main { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    }

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    }

} import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStreamReader; InputStreamReader java.io import java.io.PrintWriter; PrintWriter java.io import java.util.ArrayList; ArrayList java.util import java.util.Collections; Collections java.util import java.util.Comparator; Comparator java.util import java.util.List; List java.util import java.util.StringTokenizer; StringTokenizer java.util public class Main { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    }

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    }

} Main public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    } main {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    } BufferedReader f = new BufferedReader(new InputStreamReader(System.in)); f new BufferedReader(new InputStreamReader(System.in)) PrintWriter out = new PrintWriter(System.out); out new PrintWriter(System.out) int N = Integer.parseInt(f.readLine()); N Integer.parseInt(f.readLine()) Integer.parseInt Integer f.readLine() f.readLine f List<Double> list = new ArrayList<>(); list new ArrayList<>() StringTokenizer st = new StringTokenizer(f.readLine()); st new StringTokenizer(f.readLine()) for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        } int i = 0; int i = 0; i 0 i < N i N i++ i++ i {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        } {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        } double a = Integer.parseInt(st.nextToken()); a Integer.parseInt(st.nextToken()) Integer.parseInt Integer st.nextToken() st.nextToken st list.add(a) list.add list a Collections.sort(list) Collections.sort Collections list double ans = list.get(0); ans list.get(0) list.get list 0 for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        } int i = 1; int i = 1; i 1 i < list.size() i list.size() list.size list i++ i++ i {
            ans += list.get(i);
            ans /= 2;
        } {
            ans += list.get(i);
            ans /= 2;
        } ans += list.get(i) ans list.get(i) list.get list i ans /= 2 ans 2 out.println(ans) out.println out ans out.close() out.close out String[] args args public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    } ListComparator @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        } compare {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        } for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            } int i = 0; int i = 0; i 0 i < l1.size() i l1.size() l1.size l1 ++i ++i i {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            } {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            } if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                } l1.get(i).compareTo(l2.get(i)) != 0 l1.get(i).compareTo(l2.get(i)) l1.get(i).compareTo l1.get(i) l1.get l1 i l2.get(i) l2.get l2 i 0 {
                    return l1.get(i).compareTo(l2.get(i));
                } return l1.get(i).compareTo(l2.get(i)); l1.get(i).compareTo(l2.get(i)) l1.get(i).compareTo l1.get(i) l1.get l1 i l2.get(i) l2.get l2 i return 0; 0 List<Integer> l1 l1 List<Integer> l2 l2 Comparator public class Main { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    }

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    }

} public class Main { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    }

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    }

} Main
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.StringTokenizer;

public class Main { // Template for CF
    public static class ListComparator implements Comparator<List<Integer>> {

        @Override
        public int compare(List<Integer> l1, List<Integer> l2) {
            for (int i = 0; i < l1.size(); ++i) {
                if (l1.get(i).compareTo(l2.get(i)) != 0) {
                    return l1.get(i).compareTo(l2.get(i));
                }
            }
            return 0;
        }
    }

    public static void main(String[] args) throws IOException {
        // Check for int overflow!!!!
        // Should you use a long to store the sum or smthn?
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        int N = Integer.parseInt(f.readLine());
        List<Double> list = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(f.readLine());
        for (int i = 0; i < N; i++) {
            double a = Integer.parseInt(st.nextToken());
            list.add(a);
        }
        Collections.sort(list);
        double ans = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            ans += list.get(i);
            ans /= 2;
        }
        out.println(ans);
        out.close();
    }

}