HAII HAS A TUXGIMMEH TUXI HAS A FOO ITS 0I HAS A BAR ITS 0I HAS A BAZ ITS 0I HAS A QUZ ITS 1TUX IS NOW A NUMBRIM IN YR LOOP NERFIN YR TUX TIL BOTH SAEM TUX AN 0I HAS A PURGIMMEH PURPUR IS NOW A NUMBRFOO R SUM OF FOO AN PURBAR R SUM OF BAR AN 1BOTH SAEM BIGGR OF PRODUKT OF FOO AN QUZ AN PRODUKT OF BAR BAZ AN PRODUKT OF FOO AN QUZO RLY?YA RLYBAZ R FOOQUZ R BAROICIM OUTTA YR LOOPBAZ IS NOW A NUMBARVISIBLE SMOOSH QUOSHUNT OF BAZ QUZKTHXBYE

The input contains between 1 and 10 lines, i-th line contains an integer number xi (0 ≤ xi ≤ 9).

Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C{

	public static void main(String[] args) {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int tux;
		tux = scan.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		while(tux --> 0){
			int pur;
			pur = scan.nextInt();
			foo = foo + pur;
			bar = bar + 1;
			if(foo*quz >= bar*baz){
				baz = foo;
				quz = bar;
			}
		}
		double res = (double)baz/(double)quz;
		out.printf("%.6f", res);
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}

import java.util.Scanner;

public class B {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		double a = 0, b = 0, max = 0;
		while (t-- > 0) {
			int n = sc.nextInt();
			if(n == 1) {
				a++;
			}
			b++;
			if(a / b > max) {
				max = a/b;
			}
		}
		System.out.println(max);
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        c290 solver = new c290();
        solver.solve(1, in, out);
        out.close();
    }

    static class c290 {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int TUX = in.nextInt();
            int FOO = 0;
            int BAZ = 0;
            int QUZ = 1;
            for (int BAR = 1; BAR <= TUX; BAR++) {
                FOO += in.nextInt();
                if ((BAR * BAZ) <= (FOO * QUZ)) {
                    BAZ = FOO;
                    QUZ = BAR;
                }
            }
            out.println(((double) BAZ / QUZ));
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String next() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        c290 solver = new c290();
        solver.solve(1, in, out);
        out.close();
    }

    static class c290 {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
        /*int n = in.nextInt();
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += in.nextInt();
        }
        out.println((double) sum / n);*/
            int TUX = in.nextInt();
            int FOO = 0;
            int BAZ = 0;
            int QUZ = 1;
            for (int BAR = 1; BAR <= TUX; BAR++) {
                int PUR = in.nextInt();
                FOO = FOO + PUR;
                if (Math.max((FOO * QUZ), (BAR * BAZ)) == (FOO * QUZ)) {
                    BAZ = FOO;
                    QUZ = BAR;
                }
            }
            out.println(((double) BAZ / QUZ));
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String next() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        c290 solver = new c290();
        solver.solve(1, in, out);
        out.close();
    }

    static class c290 {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
        /*int n = in.nextInt();
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += in.nextInt();
        }
        out.println((double) sum / n);*/
            int TUX = in.nextInt();
            int FOO = 0;
            int BAR = 0;
            int BAZ = 0;
            int QUZ = 1;
            while (TUX > 0) {
                TUX--;
                int PUR = in.nextInt();
                FOO = FOO + PUR;
                BAR = BAR + 1;
                if (Math.max((FOO * QUZ), (BAR * BAZ)) == (FOO * QUZ)) {
                    BAZ = FOO;
                    QUZ = BAR;
                }
            }
            out.println(((double) BAZ / QUZ));
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String next() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.*;
import java.util.*;

public class Template implements Runnable {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    void init() throws FileNotFoundException {
        try {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        } catch (Exception e) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
    }

    class GraphBuilder {
        int n, m;
        int[] x, y;
        int index;
        int[] size;

        GraphBuilder(int n, int m) {
            this.n = n;
            this.m = m;
            x = new int[m];
            y = new int[m];
            size = new int[n];
        }

        void add(int u, int v) {
            x[index] = u;
            y[index] = v;
            size[u]++;
            size[v]++;
            index++;
        }

        int[][] build() {
            int[][] graph = new int[n][];
            for (int i = 0; i < n; i++) {
                graph[i] = new int[size[i]];
            }
            for (int i = index - 1; i >= 0; i--) {
                int u = x[i];
                int v = y[i];
                graph[u][--size[u]] = v;
                graph[v][--size[v]] = u;
            }
            return graph;
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            try {
                tok = new StringTokenizer(in.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long[] readLongArray(int size) throws IOException {
        long[] res = new long[size];
        for (int i = 0; i < size; i++) {
            res[i] = readLong();
        }
        return res;
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    <T> List<T>[] createGraphList(int size) {
        List<T>[] list = new List[size];
        for (int i = 0; i < size; i++) {
            list[i] = new ArrayList<>();
        }
        return list;
    }

    public static void main(String[] args) {
        new Template().run();
        // new Thread(null, new Template(), "", 1l * 200 * 1024 * 1024).start();
    }

    long timeBegin, timeEnd;

    void time() {
        timeEnd = System.currentTimeMillis();
        System.err.println("Time = " + (timeEnd - timeBegin));
    }

    long memoryTotal, memoryFree;

    void memory() {
        memoryFree = Runtime.getRuntime().freeMemory();
        System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10)
                + " KB");
    }

    public void run() {
        try {
            timeBegin = System.currentTimeMillis();
            memoryTotal = Runtime.getRuntime().freeMemory();
            init();
            solve();
            out.close();
            if (System.getProperty("ONLINE_JUDGE") == null) {
                time();
                memory();
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    void solve() throws IOException {
        int n = readInt();
        double sum = 0;
        double max = 0;
        for (int i = 1; i <= n; i++) {
            sum += readInt();
            max = Math.max(max, sum / i);
        }
        out.println(max);
    }

}

import java.util.*;
import java.math.*;
import java.io.*;

public class Main{
	static String s[] = new String[33];
	public static void main(String args[]) throws IOException {
		//BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int tux, foo, bar, baz, quz, pur;
		bar = 0; baz = 0; foo = 0; quz = 1;
		tux = in.nextInt();
		for(; tux > 0; tux--){
			pur = in.nextInt();
			foo += pur; bar++;
			if(foo * quz >= bar * baz){
				baz = foo;
				quz = bar;
			}

		}
		double ans = (double)baz;
		ans /= (double)quz;
		out.println(ans);
		out.flush();
	}
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Alex
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out){
	    int n = in.ri();
	    int curwins = 0;
	    double res = 0;
	    for(int i = 1; i <= n; i++) {
		    int cur = in.ri();
		    curwins += cur;
		    res = Math.max(res, (double) curwins / i);
	    }
	    out.print(res);
    }
}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}
	public int ri(){
		return readInt();
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}
	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}
	public void close() {
		writer.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class C {
	BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st = null;

	private void solution() throws IOException {
		int tux = 0;
		tux = nextInt();
		int FOO = 0;
		int BAR = 0;
		int BAZ = 0;
		int QUZ = 1;
		while (tux-- > 0) {
			int pur = nextInt();
			FOO += pur;
			BAR++;
			if (Math.max(FOO * QUZ, BAR * BAZ) == FOO * QUZ) {
				BAZ = FOO;
				QUZ = BAR;
			}
		}
		double ans = BAZ * 1.0;
		ans /= QUZ;
		System.out.println(ans);

	}

	String nextToken() throws IOException {
		if (st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(bf.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public void print(int a[]) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}

	public static void main(String args[]) throws IOException {
		new C().solution();
	}
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class T290C {

	public static void main(String[] args) {
		FastScanner in = new FastScanner();

		int TUX = in.nextInt();

		int FOO = 0;
		int BAR = 0;
		int BAZ = 0;
		int QUZ = 1;

		for (int i = 0; i < TUX; i ++) {
			int PUR = in.nextInt();

			FOO = FOO + PUR;
			BAR = BAR + 1;

			if (Math.max(FOO * QUZ, BAR * BAZ) == FOO * QUZ) {
				BAZ = FOO;
				QUZ = BAR;
			}
		}

		System.out.println(BAZ * 1.0 / QUZ);

	}
	static class FastScanner {

		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(nextToken());
		}

		long nextLong() {
			return Long.parseLong(nextToken());
		}

		double nextDouble() {
			return Double.parseDouble(nextToken());
		}

	}

}

import java.util.*;
public class cf290c {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int tux = in.nextInt();
    int foo = 0, bar = 0, baz = 0, quz = 1;
    while(tux-->0) {
      int pur = in.nextInt();
      foo += pur;
      bar++;
      if(Math.max(foo*quz, bar*baz) == foo*quz) {
        baz = foo;
        quz = bar;
      }
    }
    System.out.printf("%.10f%n", baz*1./quz);
  }
}

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
	private static BufferedReader br;
	private static StringTokenizer st;
	private static PrintWriter pw;

	static final long MOD = 1000000007;

	public static void main(String[] args) throws IOException	{
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int qq = 1;
		//int qq = Integer.MAX_VALUE;
		//int qq = readInt();
		for(int casenum = 1; casenum <= qq; casenum++)	{
			int n = readInt();
			double ret = 0;
			int num = 0;
			for(int i = 1; i <= n; i++)	{
				num += readInt();
				ret = Math.max(ret, 1.0*num/i);
			}
			pw.println(ret);
		}
		pw.close();
	}

	public static boolean valid(int[] order)	{
		for(int k = 0; k < order.length; k++)	{
			int curr = order[k];
			boolean[] seen = new boolean[order.length];
			while(true)	{
				if(seen[curr])	{
					break;
				}
				seen[curr] = true;
				curr = order[curr];
			}
			if(!seen[0])	{
				return false;
			}
		}
		return true;
	}

	public static long solve(int index, int[] order)	{
		if(index == order.length)	{
			return valid(order) ? 1 : 0;
		}
		long ret = 0;
		for(int i = 0; i < order.length; i++)	{
			order[index] = i;
			ret += solve(index+1, order);
		}
		return ret;
	}

	private static void exitImmediately()	{
		pw.close();
		System.exit(0);
	}

	private static long readLong() throws IOException	{
		return Long.parseLong(nextToken());
	}

	private static double readDouble() throws IOException	{
		return Double.parseDouble(nextToken());
	}

	private static int readInt() throws IOException	{
		return Integer.parseInt(nextToken());
	}

	private static String nextToken() throws IOException	{
		while(st == null || !st.hasMoreTokens())	{
			if(!br.ready())	{
				exitImmediately();
			}
			st = new StringTokenizer(br.readLine().trim());
		}
		return st.nextToken();
	}
}

import java.io.*;
import java.math.*;
import java.util.*;

public class Main {

    static final double eps = 1e-8;
    static final int mod = 1000 * 1000 * 1000 + 7;
    static final BigInteger modB = BigInteger.valueOf(mod);
    static int n;

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        pw = new PrintWriter(System.out);
        try {
           int tux=sc.nextInt();
           int foo=0;
           int bar=0;
           int baz=0;
           int quz=1;
           for (int i=tux;tux>0;tux--)
           {
               int pur = sc.nextInt();
               foo+=pur;
               bar++;
               if (Math.max(foo*quz,bar*baz)==foo*quz)
               {
                   baz=foo;
                   quz=bar;
               }
           }
           double x = (double)baz/(double)quz;
           pw.println(x);
        }

        finally {

            pw.close();
        }
    }

    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st ;
    static PrintWriter pw;
    static int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }
    static long nextLong() throws IOException {
        in.nextToken();
        return (long) in.nval;
    }
    static double nextDouble() throws IOException {
        in.nextToken();
        return in.nval;
    }
    static String next() throws IOException {
        in.nextToken();
        return in.sval;
    }
    static void outArray(int[] O) {
        for(int i = 0; i < O.length - 1; i++)
            pw.print(O[i] + " ");
        pw.println(O[O.length - 1]);
    }
    static void exit(Object arg)
    {
        pw.println(arg);
        pw.flush();
        System.exit(0);
    }
}

import java.io.*;
import java.util.*;

public class C {

    void solve() throws IOException {
        in("__std"); out("__std");

        int tux = readInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        while (tux-- > 0) {
            int pur = readInt();
            foo += pur;
            bar += 1;
            int max = Math.max(foo * quz, bar * baz);
            if (max == foo * quz) {
                baz = foo;
                quz = bar;
            }
        }
        println(1.0 * baz / quz);

        exit();
    }

    void in(String name) throws IOException {
        if (name.equals("__std")) {
            in = new BufferedReader(new InputStreamReader(System.in));
        } else {
            in = new BufferedReader(new FileReader(name));
        }
    }

    void out(String name) throws IOException {
        if (name.equals("__std")) {
            out = new PrintWriter(System.out);
        } else {
            out = new PrintWriter(name);
        }
    }

    void exit() {
        out.close();
        System.exit(0);
    }

    char readChar() throws IOException {
        return (char) in.read();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readToken());
    }

    long readLong() throws IOException {
        return Long.parseLong(readToken());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readToken());
    }

    String readLine() throws IOException {
        st = null;
        return in.readLine();
    }

    String readToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    boolean eof() throws IOException {
        return !in.ready();
    }

    void print(String format, Object ... args) {
        out.print(new Formatter(Locale.US).format(format, args));
    }

    void println(String format, Object ... args) {
        out.println(new Formatter(Locale.US).format(format, args));
    }

    void print(Object value) {
        out.print(value);
    }

    void println(Object value) {
        out.println(value);
    }

    void println() {
        out.println();
    }

    StringTokenizer st;

    BufferedReader in;
    PrintWriter out;

    public static void main(String[] args) throws IOException {
        new C().solve();
    }
}

import java.io.*;
import java.util.*;

public class C implements Runnable {

	private void solve() throws IOException {
		int tux = nextInt(), foo = 0, bar = 0, baz = 0, quz = 1;
		while (tux-- > 0) {
			int pur = nextInt();
			foo += pur;
			bar++;
			if (Math.max(foo * quz, bar * baz) == foo * quz) {
				baz = foo;
				quz = bar;
			}
		}
		print(baz * 1. / quz);
	}

	public static void main(String[] args) {
		new C().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			writer = new PrintWriter(System.out);
			solve();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(261);
		}
	}

	void halt() {
		writer.close();
		System.exit(0);
	}

	void print(Object... objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	void println(Object... objects) {
		print(objects);
		writer.println();
	}

	String nextLine() throws IOException {
		return reader.readLine();
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens())
			tokenizer = new StringTokenizer(nextLine());
		return tokenizer.nextToken();
	}

	int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}
}

import java.util.Scanner;

public class ProblemC {

	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int tux = sc.nextInt();
		int foo = 0;
		int bar = 0;
		double baz = 0;
		double quz = 1;
		for(;tux>0;tux--){
			int pur;
			pur = sc.nextInt();
			foo = foo + pur;
			bar++;
			if (Math.max(foo*quz, bar*baz) == foo*quz){
				baz = foo;
				quz = bar;
			}
		}
		System.out.println(baz / quz);
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Fabian Conejo (FabianConP)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int tux = in.readInt();
        int[] nums = in.readInts(tux);
        double ans = 0, sum=0;
        for(int i=0; i<tux;i++){
            sum+=nums[i];
            ans = Math.max(ans,sum/(i+1));
        }
        out.printLine(ans);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public int[] readInts( int n ){
        int ans[]=new int[n];
        for( int i=0; i<n; i++ ) ans[i]=readInt();
        return ans;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object...objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object...objects) {
        print( objects );
        writer.println();
    }

    public void close() {
        writer.close();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class P290C_WTF {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int tux = Integer.parseInt(in.readLine());
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        for (; tux > 0; tux--) {
            int pur = Integer.parseInt(in.readLine());
            foo = foo + pur;
            bar = bar + 1;
            if (Math.max(foo*quz,bar*baz) == foo*quz) {
                baz = foo;
                quz = bar;
            }
        }
        System.out.println((double)baz/(double)quz);
    }

}

public class Problem290C {
    public static void main(String[] args){
        java.util.Scanner in = new java.util.Scanner(System.in);

        int tux = Integer.parseInt(in.nextLine());
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;

        for(; tux > 0; tux--){
            int pur = Integer.parseInt(in.nextLine());
            foo = foo + pur;
            bar++;

            if(foo*quz >= bar*baz){
                baz = foo;
                quz = bar;
            }
        }

        System.out.println((double)baz / quz);
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);

		int tux = s.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;

		while(tux != 0){
			int pur = s.nextInt();
			foo = foo+pur;
			bar = bar+1;

			if ((foo*quz) >= (bar*baz)){
				baz = foo;
				quz = bar;
			}
			tux--;
		}
		System.out.println((double)baz/quz);

	}
}

import java.util.*;
public class j {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);

    int n = input.nextInt();
    double res = 0;
    double w = 0, l = 0;
    for(int i =0 ; i<n; i++)
    {
        if(input.nextInt()==1) w++;
        else l++;
        res = Math.max(res, w/(l+w));
    }
    System.out.println(res);
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main implements Runnable {

	private void solve() throws IOException {
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		while (tux != 0) {
			int pur = nextInt();
			foo += pur;
			++bar;
			if (Math.max(foo * quz, bar * baz) == foo * quz) {
				baz = foo;
				quz = bar;
			}
			--tux;
		}

		out.println((baz + .0) / quz);
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String line = in.readLine();
			if (line == null)
				return null;
			eat(line);
		}
		return st.nextToken();
	}

	public static void main(String[] args) {
		new Thread(null, new Main(), "Main", 1 << 28).start();
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			eat("");
			solve();
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(566);
		}
	}

	private void eat(String s) {
		st = new StringTokenizer(s);
	}

}

import java.util.Scanner;
public class WTF {
	public static void main(String[] args) {
		Scanner in = new Scanner (System.in);
		int n = in.nextInt();
		int get =0;
		double max =0;
		for(int i=1;i<=n;i++){
			int x = in.nextInt();
			get+=x;
			max =Math.max(max, (double)get/i);
		}
		System.out.printf("%.6f\n",max);
	}
}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class C implements Runnable {

    /*
    for
     foo := foo + pur
     bar := bar + 1
     ?  foo * quz,  bar * baz,  foo * quz
      baz := foo
      quz := bar

    baz / quz
     */

    public void solve() throws IOException {
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        int tux = in.nextInt();
        for ( int i = 0; i < tux; i ++ ) {
            int pur = in.nextInt();
            foo += pur;
            bar += 1;
            if ( baz * bar <= foo * quz ) {
                baz = foo;
                quz = bar;
            }
        }
        out.println( 1.0 * baz / quz );
    }

    public Scanner in;

    public PrintWriter out;

    C() throws IOException {
        in = new Scanner(System.in);
        // in = new StreamTokenizer( new InputStreamReader( System.in ) );
        out = new PrintWriter(System.out);
    }

//    int nextInt() throws IOException {
//        in.nextToken();
//        return ( int ) in.nval;
//    }

    void check(boolean f, String msg) {
        if (!f) {
            out.close();
            throw new RuntimeException(msg);
        }
    }

    void close() throws IOException {
        out.close();
    }

    public void run() {
        try {
            solve();
            close();
        } catch (Exception e) {
            e.printStackTrace(out);
            out.flush();
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        new Thread(new C()).start();
    }
}

import java.io.*;

public class Main {
  public static void main(String[] args) throws Throwable {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int tux = Integer.parseInt(br.readLine());
    int foo = 0;
    int bar = 0;
    int baz = 0;
    int quz = 1;
    for (int i = 0; i < tux; i++) {
      int pur = Integer.parseInt(br.readLine());
      foo += pur;
      bar++;
      if (foo * quz > bar * baz) {
        baz = foo;
        quz = bar;
      }
    }
    System.out.format("%.6f%n", (double) baz / (double) quz);
  }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class Solver {

	public static void main(String[] Args) throws NumberFormatException,
			IOException {
		new Solver().Run();
	}

	PrintWriter pw;
	StringTokenizer Stok;
	BufferedReader br;

	public String nextToken() throws IOException {
		while (Stok == null || !Stok.hasMoreTokens()) {
			Stok = new StringTokenizer(br.readLine());
		}
		return Stok.nextToken();
	}

	public int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextToken());
	}

	public long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(nextToken());
	}

	public void Run() throws NumberFormatException, IOException {
		//br = new BufferedReader(new FileReader("input.txt"));
		//pw = new PrintWriter("output.txt");
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new OutputStreamWriter(System.out));
		int TUX = nextInt(), FOO = 0 , BAR = 0 , BAZ = 0, QUZ = 1;
		int PUR;
		for (;TUX>0;TUX--){
			PUR = nextInt();
			FOO += PUR;
			BAR++;
			if (FOO*QUZ>BAR*BAZ){
				BAZ = FOO;
				QUZ = BAR;
			}
		}
		float res = BAZ;
		pw.print(res/QUZ);
		pw.flush();
		pw.close();
	}

}

import java.io.*;
import java.util.*;

public class PrC {
	public static void main(String[] args) throws IOException {
		new PrC().run();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String nextToken() throws IOException {
		while(st == null || !st.hasMoreTokens()) {
			st = new StringTokenizer(in.readLine());
		}
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out, true);
		solve();
		out.flush();
	}

	void solve() throws IOException {
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for(int i = tux; i > 0; i--) {
			int pur = nextInt();
			foo = foo + pur;
			bar = bar + 1;
			if(Math.max(foo*quz, bar*baz) == foo*quz) {
				baz = foo;
				quz = bar;
			}
		}
		double baz1 = baz;
		baz1 = baz1/quz;
		out.println(baz1);
	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;

public class Main {

    public static void main(String[] args) throws NumberFormatException,
            IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int TUX, FOO = 0, BAR = 0;
        double  BAZ = 0, QUZ = 1;
        boolean IT;
        TUX = Integer.parseInt(in.readLine());
        for (; !((TUX == 0)); TUX--) {
            int PUR = Integer.parseInt(in.readLine());
            FOO = (FOO + PUR);
            BAR = (BAR + 1);
            IT = (Math.max((FOO * QUZ), (BAR * BAZ)) == FOO * QUZ);
            if (IT) {
                BAZ = FOO;
                QUZ = BAR;
            }
        }
        System.out.println((double)BAZ / QUZ);

    }
    }

import java.io.*;
public class Main {

    public static void main(String[] args) {
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       int tux;
        try{
       tux = Integer.parseInt(br.readLine());
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        while(tux-- > 0)
        {
            int pur = Integer.parseInt(br.readLine());
            foo = foo + pur;
            bar = bar + 1;
            if(Math.max(foo * quz, bar * baz) == foo*quz)
            {
                baz = foo;
                quz = bar;
            }
        }
            System.out.println(1.0 * baz/quz);
        }catch(Exception e){}
    }
}

import java.io.IOException;
import java.util.Scanner;

public class TC2
{
    public static void main( String[] args ) throws IOException
    {
        Scanner s=new Scanner( System.in );
        int N=s.nextInt();

        int foo=0, bar=0, baz=0, quz=1;

        for( int i=0; i<N; i++ )
        {
            int pur=s.nextInt();
            foo=foo+pur;
            bar++;
            if( Math.max( foo*quz, bar*baz ) == foo*quz )
            {
                baz=foo;
                quz=bar;
            }
        }

        double res=1.0*baz/quz;
        System.out.println(res );
    }

}

//package afc2013;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class C {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = ni();
		int f = 0, r = 0, z = 0, q = 1;
		for(int i = 0;i < n;i++){
			int p = ni();
			f += p;
			r++;
//			int u = Integer.parseInt(Integer.toString(r) + Integer.toString(z));
			if(Math.max(f*q, r*z) == f*q){
				z = f;
				q = r;
			}
		}
		out.printf("%.9f\n", (double)z/q);
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new C().run(); }

	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import static java.util.Collections.*;
import java.io.*;

public class _290_C_WTF {

	public void solve() {
		int tux = ni();
		int d=0;
		int foo=0;
		int bar=0;
		int baz=0;
		int quz=1;
		for (int i = 0; i < tux; i++) {
			int pur = ni();
			foo+=pur;
			bar++;
			pr(foo,bar,baz,quz,foo*quz,bar*baz);
			if(foo*quz>bar*baz){
				baz=foo;
				quz=bar;
			}

		}
		out.println(baz/(double)quz);
	}

	// IO methods

	void run() throws Exception {
		long s = System.currentTimeMillis();
		solve();
		out.flush();
		pr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception {
		new _290_C_WTF().run();
	}

	InputStream in = System.in;
	PrintWriter out = new PrintWriter(System.out);

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = in.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	public String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != //
									// ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	public char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	public int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	public long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	void pr(Object... ob) {
		if (!oj)
			System.out.println(Arrays.deepToString(ob).replace("],", "],\n"));
	}
}

import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author N-AssassiN
 */
public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int tux = scanner.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        while (tux > 0) {
            tux--;
            int pur = scanner.nextInt();
            foo += pur;
            bar++;
            int temp1 = foo * quz;
            int temp2 = bar * baz;
            if (temp1 > temp2) {
                baz = foo;
                quz = bar;
            }
        }
        System.out.println((double) baz / (double) quz);
    }
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Saul
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
  public void solve(int testNumber, Scanner in, PrintWriter out) {
    int n = in.nextInt();
    double foo = 0, bar = 0, baz = 0, quz = 1;
    for (int i = 0; i < n; i++) {
      foo += in.nextInt();
      bar++;
      if ( foo * quz > bar * baz ){
        baz = foo;
        quz = bar;
      }
    }

    out.print(baz / quz);
  }
}

import java.io.InputStreamReader;
import java.util.Scanner;

public class ProblemC {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new InputStreamReader(System.in));
        int tux = sc.nextInt();
        int foo = 0, bar = 0, baz = 0, quz = 1;
        while (tux > 0) {
            int pur = sc.nextInt();
            foo = foo + pur;
            bar = bar + 1;
            if (foo * quz >= bar * baz) {
                baz = foo;
                quz = bar;
            }
            tux--;
        }
        sc.close();
        System.out.println(baz / (double)quz);
    }
}

import java.io.*;
import java.math.*;
import java.util.*;

public class Main {
    private IO io;
    private int ioMode = -1;
    private String problemName = "";
    private final String mjArgument = "master_j";

    public static void main(String programArguments[]) throws IOException{
        if(programArguments != null && programArguments.length > 0)
            new Main().run(programArguments[0]);
        else
            new Main().run(null);
    }

    private void run(String programArgument) throws IOException {
//         _______________________________________________ _________
//        |   Input Mode     |      Output Mode    | mode | comment |
//        |------------------|---------------------|----- |---------|
//        |   input.txt      |      System.out     |  0   |    mj   |
//        |   System.in      |      System.out     |  1   |  T / CF |
//        |<problemName>.in  |  <problemName>.out  |  2   |         |
//        |   input.txt      |      output.txt     |  3   |    C    |
//        |__________________|_____________________|______|_________|
        long nanoTime = 0;
        if(programArgument != null && programArgument.equals(mjArgument)) // mj
            ioMode = 0;
        else if(System.getProperty("ONLINE_JUDGE") != null) // T / CF
            ioMode = 1;
        else
            ioMode = 2;
        switch(ioMode){
            case -1:
                try{
                    throw new Exception("<ioMode> init failure") ;
                }catch (Exception e){
                    e.printStackTrace();
                }
                return;
            case 0:
                break;
            case 1:
                break;
            case 2:
                if(problemName.length() == 0){
                    try{
                        throw new Exception("<problemName> init failure");
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    return;
                }
            case 3:
                break;
        }
        io = new IO(ioMode, problemName);
        if(ioMode == 0){
            System.out.println("File output : \n<start>");
            System.out.flush();
            nanoTime = System.nanoTime();
        }
        solve();
        io.flush();
        if(ioMode == 0){
            System.out.println("</start>");
            long t = System.nanoTime() - nanoTime;
            int d3 = 1000000000, d2 = 1000000, d1 = 1000;
            if(t>=d3)
                System.out.println(t/d3 + "." + t%d3 + " seconds");
            else if(t>=d2)
                System.out.println(t/d2 + "." + t%d2 + " millis");
            else if(t>=d1)
                System.out.println(t/d1 + "." + t%d1 + " micros");
            else
                System.out.println(t + " nanos");
            System.out.flush();
        }
    }

    private void solve() throws IOException {
        int tux = io.nI(), foo=0, bar=0, baz=0, quz=1;
        for(; tux>0; tux--){
            int pur = io.nI();
            foo += pur;
            bar++;
            if(Math.max(foo*quz, bar*baz) == foo*quz){
                baz = foo;
                quz = bar;
            }
        }
        io.wf("%.7f\n", 1.0*baz/quz);
    }//2.2250738585072012e-308

    /**
     * Input-output class
     * @author master_j
     * @version 0.2.5
     */
    @SuppressWarnings("unused")
    private class IO{
        private boolean alwaysFlush;
        StreamTokenizer in; PrintWriter out; BufferedReader br; Reader reader; Writer writer;
        public IO(int ioMode, String problemName) throws IOException{
            Locale.setDefault(Locale.US);
//         _______________________________________________ _________
//        |   Input Mode     |      Output Mode    | mode | comment |
//        |------------------|---------------------|----- |---------|
//        |   input.txt      |      System.out     |  0   |    mj   |
//        |   System.in      |      System.out     |  1   |  T / CF |
//        |<problemName>.in  |  <problemName>.out  |  2   |         |
//        |   input.txt      |      output.txt     |  3   |    C    |
//        |__________________|_____________________|______|_________|
            switch(ioMode){
                case 0:
                    reader = new FileReader("input.txt");
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 1:
                    reader = new InputStreamReader(System.in);
                    writer = new OutputStreamWriter(System.out);
                    break;
                case 2:
                    reader = new FileReader(problemName + ".in");
                    writer = new FileWriter(problemName + ".out");
                    break;
                case 3:
                    reader = new FileReader("input.txt");
                    writer = new FileWriter("output.txt");
                    break;
            }
            br = new BufferedReader(reader);
            in = new StreamTokenizer(br);
            out = new PrintWriter(writer);
            alwaysFlush = false;
        }
        public void setAlwaysFlush(boolean arg){alwaysFlush = arg;}
        public void wln(){out.println(); if(alwaysFlush)flush();}
        public void wln(int arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(long arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(double arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(String arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(boolean arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(char arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(float arg){out.println(arg); if(alwaysFlush)flush();}
        public void wln(Object arg){out.println(arg); if(alwaysFlush)flush();}
        public void w(int arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(long arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(double arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(String arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(boolean arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(char arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(float arg){out.print(arg); if(alwaysFlush)flush();}
        public void w(Object arg){out.print(arg); if(alwaysFlush)flush();}
        public void wf(String format, Object...args){out.printf(format, args); if(alwaysFlush)flush();}
        public void flush(){out.flush();}
        public int nI() throws IOException {in.nextToken(); return(int)in.nval;}
        public long nL() throws IOException {in.nextToken(); return(long)in.nval;}
        public String nS() throws IOException {in.nextToken(); return in.sval;}
        public double nD() throws IOException {in.nextToken(); return in.nval;}
        public float nF() throws IOException {in.nextToken(); return (float)in.nval;}
        public char nC() throws IOException {return (char)br.read();}
        public void wc(char...arg){for(char c : arg){in.ordinaryChar(c);in.wordChars(c, c);}}
        public void wc(String arg){wc(arg.toCharArray());}
        public void wc(char arg0, char arg1){in.ordinaryChars(arg0, arg1); in.wordChars(arg0, arg1);}
        public boolean eof(){return in.ttype == StreamTokenizer.TT_EOF;}
        public boolean eol(){return in.ttype == StreamTokenizer.TT_EOL;}
    }
}

//package Round_FirstApril_2013;

import java.util.*;
import java.io.*;

import static java.lang.Math.*;

public class C {

    void solve () throws IOException {
        int n = in.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        for (int i = n; i>0; i--){
            int pur = in.nextInt();
            foo += pur;
            bar ++;
            if (foo * quz > baz * bar){
                baz = foo;
                quz = bar;
            }
        }
        out.println (1.0 * baz / quz);

    }

    String input = "";
    String output = "";

    FastScanner in;
    PrintWriter out;

    void run () {
        try {
            BufferedReader bf;
            if (input.length() == 0)
                bf = new BufferedReader(new InputStreamReader(
                        System.in));
            else
                bf = new BufferedReader(new FileReader(input));
            in = new FastScanner(bf);

            if (output.length() == 0)
                out = new PrintWriter(System.out);
            else
                out = new PrintWriter(new File(output));

            solve();

            out.close();
        } catch (Exception ex) {
            out.close();
            ex.printStackTrace();
        }
    }

    public static void main (String[] args) {
        new C().run();
    }

    class FastScanner {
        BufferedReader bf;
        StringTokenizer st;

        FastScanner(BufferedReader bf) {
            this.bf = bf;
        }

        String next () throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        int nextInt () throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong () throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble () throws IOException {
            return Double.parseDouble(next());
        }

        int[] readIntArray (int n) throws IOException {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        long[] readLongArray (int n) throws IOException {
            long a[] = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
    }
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}

	private void solve() throws IOException {
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		int n = nextInt();
		for (int i = 0; i < n; i++) {
			int pur = nextInt();
			foo += pur;
			bar++;
			if (max(foo * quz, bar * baz) == foo * quz) {
				baz = foo;
				quz = bar;
			}
		}
		out.println(1. * baz / quz);
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.io.*;
import java.util.*;

public class FirstApril {
    FastScanner in;
    PrintWriter out;

    void solve() {
        int n = in.nextInt();
        if (n == 0) {
            out.println(0);
            return;
        }
        int sum = 0;
        double max = 0;
        for (int i = 0; i < n; i++) {
            sum += in.nextInt();
            max = Math.max(sum / (1. + i), max);
        }
        out.println(max);
        /*
        String s = in.next();
        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == 'H') {
                sum += 12;
            } else {
                sum += s.length();
            }
        }
        out.println(sum % 2==0 ? "Yes" : "No");
        */
    }

    void run() {
        try {
            in = new FastScanner(new File("object.in"));
            out = new PrintWriter(new File("object.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }
    }

    public static void main(String[] args) {
        new FirstApril().runIO();
    }
}

import java.io.*;
import java.math.*;
import static java.lang.Math.*;
import java.security.SecureRandom;
import static java.util.Arrays.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import sun.misc.Regexp;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import sun.net.www.content.text.plain;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
    StreamTokenizer in;
    PrintWriter out;
//deb////////////////////////////////////////////////

    public static void deb(String n, Object n1) {
        System.out.println(n + " is : " + n1);
    }

    public static void deb(int[] A) {

        for (Object oo : A) {
            System.out.print(oo + " ");
        }
        System.out.println("");
    }

    public static void deb(long[] A) {

        for (Object oo : A) {
            System.out.print(oo + " ");
        }
        System.out.println("");
    }

    public static void deb(boolean[] A) {

        for (Object oo : A) {
            System.out.print(oo + " ");
        }
        System.out.println("");
    }

    public static void deb(double[] A) {

        for (Object oo : A) {
            System.out.print(oo + " ");
        }
        System.out.println("");
    }

    public static void deb(String[] A) {

        for (Object oo : A) {
            System.out.print(oo + " ");
        }
        System.out.println("");
    }

    public static void deb(int[][] A) {
        for (int i = 0; i < A.length; i++) {
            for (Object oo : A[i]) {
                System.out.print(oo + " ");
            }
            System.out.println("");
        }

    }

    public static void deb(double[][] A) {
        for (int i = 0; i < A.length; i++) {
            for (Object oo : A[i]) {
                System.out.print(oo + " ");
            }
            System.out.println("");
        }

    }

    public static void deb(long[][] A) {
        for (int i = 0; i < A.length; i++) {
            for (Object oo : A[i]) {
                System.out.print(oo + " ");
            }
            System.out.println("");
        }

    }

    public static void deb(String[][] A) {
        for (int i = 0; i < A.length; i++) {
            for (Object oo : A[i]) {
                System.out.print(oo + " ");
            }
            System.out.println("");
        }

    }
    /////////////////////////////////////////////////////////////

    int nextInt() throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    long nextLong() throws IOException {
        in.nextToken();
        return (long) in.nval;
    }

    void run() throws IOException {
//          in = new StreamTokenizer(new BufferedReader(new FileReader("input.txt")));
        // out = new PrintWriter(new FileWriter("output.txt"));
        in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(new OutputStreamWriter(System.out));
        solve();
        out.flush();
    }
//boolean inR(int x,int y){
//return (x<=0)&&(x<4)&&(y<=0)&&(y<4);
//}

    @SuppressWarnings("unchecked")
    void solve() throws IOException {
        //   BufferedReader re= new BufferedReader(new FileReader("C:\\Users\\ASELA\\Desktop\\PROBLEMSET\\input\\F\\10.in"));
       //   BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
        //   Scanner sc = new Scanner(System.in);
 int n=nextInt();
 double max=0;
 double wc=0,tot=0;
        for (int i = 0; i < n; i++) {
            tot+=1;
            if(nextInt()==1)wc+=1;
            if(max*tot<wc)
                max=wc/tot;

        }
        System.out.println(max);
    }

}

import java.util.*;
import java.math.*;
import java.io.*;

public class Solurion {

	private void solve() throws Exception {
		/*int n = nextInt();
		double sum = 0;
		for (int i = 0; i < n; ++i) {
			sum += nextInt();
		}
		out.println(sum / n);*/
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		/*if (foo * quz >= bar * baz )
		//if (foo * quz * bar)
		{
			System.out.println("YUP");
		} else {
			System.out.println("NO");
		}*/
		for (int i = 0; i < tux; ++i) {
			int pur = nextInt();
			foo = foo + pur;
			bar = bar + 1;
			if (foo * quz >= bar * baz )
			{
				baz = foo;
				quz = bar;
			}
		}
		out.println((double) baz / quz);
	}

	public void run() {
		try {
			solve();
		} catch (Exception e) {
			NOO(e);
		} finally {
			out.close();
		}
	}

	PrintWriter out;
	BufferedReader in;
	StringTokenizer St;

	void NOO(Exception e) {
		e.printStackTrace();
		System.exit(42);
	}

	int nextInt() {
		return Integer.parseInt(nextToken());
	}

	long nextLong() {
		return Long.parseLong(nextToken());
	}

	double nextDouble() {
		return Double.parseDouble(nextToken());
	}

	String nextToken() {
		while (!St.hasMoreTokens()) {
			try {
				String line = in.readLine();
				if (line == null)
					return null;
				St = new StringTokenizer(line);
			} catch (Exception e) {
				NOO(e);
			}
		}
		return St.nextToken();
	}

	private Solurion(String name) {
		try {
			in = new BufferedReader(new FileReader("input.txt"));
			St = new StringTokenizer("");
			out = new PrintWriter(new FileWriter("output.txt"));
		} catch (Exception e) {
			NOO(e);
		}
	}

	private Solurion() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			St = new StringTokenizer("");
			out = new PrintWriter(System.out);
		} catch (Exception e) {
			NOO(e);
		}
	}

	public static void main(String[] args) {
		//Locale.setDefault(Locale.US);
		new Solurion().run();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class C {

	BufferedReader in;
	StringTokenizer st;
	PrintWriter out;

	String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	int nextInt() throws Exception {
		return Integer.parseInt(next());
	}

	long nextLong() throws Exception {
		return Long.parseLong(next());
	}

	double nextDouble() throws Exception {
		return Double.parseDouble(next());
	}

	void solve() throws Exception {
		int TUX = nextInt() - 1;
		int FOO = 0;
		int BAR = 0;
		int BAZ = 0;
		int QUZ = 1;
		while (TUX >= 0) {
			//System.err.println(TUX);
			int PUR = nextInt();
			FOO = (FOO + PUR);
			BAR = (BAR + 1);
			if (((Math.max((FOO * QUZ), (BAR * BAZ))) == (FOO * QUZ))) {
				BAZ = FOO;
				QUZ = BAR;
			}
			TUX--;
		}
		out.println(1.0 * BAZ / QUZ);
	}

	void run() {
		try {
			Locale.setDefault(Locale.US);
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			solve();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public static void main(String[] args) {
		new C().run();
	}

}

import java.io.*;
import java.util.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

	public void solve () throws Throwable {
		int n = sc.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (int i = 0; i < n; i++) {
			int pur = sc.nextInt();
			foo += pur;
			bar++;
			if (max (foo * quz, bar * baz) == foo * quz) {
				baz = foo;
				quz = bar;
			} else {
				break;
			}
		}
		double result = (double) baz / quz;
		out.printf("%.4f", result);
	}

	BufferedReader in;
	PrintWriter out;
	FastScanner sc;

	static Throwable uncaught;

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			sc = new FastScanner(in);
			solve();
		} catch (Throwable t) {
			Solution.uncaught = t;
		} finally {
			out.close();
		}
	}

	public static void main(String[] args) throws Throwable {
		Thread t = new Thread(null, new Solution(), "", (1 << 26));
		t.start();
		t.join();
		if (uncaught != null) {
			throw uncaught;
		}
	}

}

class FastScanner {

	BufferedReader reader;
	StringTokenizer strTok;

	public FastScanner(BufferedReader reader) {
		this.reader = reader;
	}

	public String nextToken() throws IOException {
		while (strTok == null || !strTok.hasMoreTokens()) {
			strTok = new StringTokenizer(reader.readLine().trim());
		}
		return strTok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

}

import java.util.Scanner;
import java.io.*;

// The "ProblemC" class.
public class ProblemC
{
    public static void main (String[] args) throws IOException
    {
		//Scanner inFile = new Scanner(new File("DATA_C.txt"));
		Scanner inSys = new Scanner(System.in);
		//PrintStream outFile = new PrintStream(new File("OUT_C.txt"));
		PrintStream outSys = new PrintStream(System.out);

		//int numloops = Integer.parseInt(inFile.nextLine());
		int numloops = Integer.parseInt(inSys.nextLine());
		int sum = 0;
		int[] nums = new int[numloops];

		for(int i = 0; i < numloops; i++)
		{
			//nums[i] = Integer.parseInt(inFile.nextLine());
			nums[i] = Integer.parseInt(inSys.nextLine());
		}

		int x = 0;
		if(numloops > 1)
		{
			while(nums[x] <= nums[x+1])
			{
				x++;
				if(x == (numloops-1))
				{
					break;
				}
			}
			x++;

			for(int i = 0; i < x; i++)
			{
				sum+=nums[i];
			}

			if(x != 0)
			{
				System.out.println(1.0 * sum / x);
			}
			else
			{
				System.out.println("0");
			}
		}
		else
		{
			System.out.println(nums[0]);
		}
    } // main method
} // ProblemC class

import java.io.*;
import java.util.*;

public class Solution {
    public static void main (String[] args) throws IOException {
        boolean online = "true".equals(System.getProperty("ONLINE_JUDGE"));
        if (online) {
            in = new InputReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        else {
            in = new InputReader(new FileReader("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        }

        new Solution().run();

        out.close();
    }

    private void run () {
        boolean it = false;
        int foo = 0,
            bar = 0,
            baz = 0,
            quz = 1,
            tux = in.nextInt();
        for (int i = 0; i < tux; ++i) {
            int pur = in.nextInt();
            foo += pur;
            ++bar;
            it = (foo*quz >= bar*baz);
            if (it) {
                baz = foo;
                quz = bar;
            }
        }
        out.println(baz*1.0/quz);
    }

    private static InputReader in;
    private static PrintWriter out;
}

class InputReader {
    public InputReader (Reader r) {
        buff = new BufferedReader(r);
        try {
            str = new StringTokenizer(buff.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String next () {
        while (!str.hasMoreTokens())
            try {
                str = new StringTokenizer(buff.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        return str.nextToken();
    }

    public int nextInt () {
        return Integer.parseInt(this.next());
    }

    public long nextLong () {
        return Long.parseLong(this.next());
    }

    private static BufferedReader buff;
    private static StringTokenizer str;
}

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Egor Kulikov (egor@egork.net)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
		int count = in.readInt();
		int[] numbers = IOUtils.readIntArray(in, count);
		double answer = 0;
		int sum = 0;
		for (int i = 0; i < count; i++) {
			sum += numbers[i];
			answer = Math.max(answer, (double)sum / (i + 1));
		}
		out.printLine(answer);
	}
}

class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public OutputWriter(Writer writer) {
		this.writer = new PrintWriter(writer);
	}

	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

    public void printLine(Object...objects) {
		print(objects);
		writer.println();
	}

	public void close() {
		writer.close();
	}

	}

class IOUtils {

	public static int[] readIntArray(InputReader in, int size) {
		int[] array = new int[size];
		for (int i = 0; i < size; i++)
			array[i] = in.readInt();
		return array;
	}

	}

import java.util.Scanner;

public class MagicMonkey {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int tux = sc.nextInt();
		int foo=0,bar=0,baz=0,quz=1;
		while(tux-->0){
			int pur = sc.nextInt();
			foo = foo+pur;
			bar++;
			if(Math.max(foo*quz,bar*baz)==foo*quz){
				baz = foo;
				quz = bar;
			}
		}
		System.out.println((baz+0.0)/quz);
	}

}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileReader;
import java.util.Arrays;
import java.util.Locale;
import java.util.Iterator;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Abrackadabra
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int tux = in.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;

        for (int i = 0; i < tux; i++) {
            int pur = in.nextInt();

            foo += pur;
            bar++;

            if (Math.max(foo * quz, bar * baz) == foo * quz) {
                baz = foo;
                quz = bar;
            }
        }

        out.println(1d * baz / quz);
    }
}

class InputReader implements Iterable<String> {
    BufferedReader br;
    StringTokenizer in;

    public InputReader(String fileName) {
        try {
            br = new BufferedReader(new FileReader(fileName));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public InputReader(InputStream inputStream) {
        br = new BufferedReader(new InputStreamReader(inputStream));
    }

    String lastLine = null;

    boolean hasMoreTokens() {
        while (in == null || !in.hasMoreTokens()) {
            lastLine = nextLine();
            if (lastLine == null) {
                return false;
            }
            in = new StringTokenizer(lastLine);
        }
        return true;
    }

    public String nextString() {
        return hasMoreTokens() ? in.nextToken() : null;
    }

    public String nextLine() {
        boolean somethingLeft = in != null && in.hasMoreTokens();
        in = null;
        if (somethingLeft) {
            return lastLine;
        }
        try {
            return br.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public int nextInt() {
        return Integer.parseInt(nextString());
    }

    public Iterator<String> iterator() {
        return new Iterator<String>() {
            @Override
            public boolean hasNext() {
                return hasMoreTokens();
            }

            @Override
            public String next() {
                return nextString();
            }

            @Override
            public void remove() {
                throw new RuntimeException();
            }
        };
    }
}

class OutputWriter {

    final PrintWriter out;

    public OutputWriter(String fileName) {
        try {
            out = new PrintWriter(fileName);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    public OutputWriter(OutputStream outputStream) {
        out = new PrintWriter(outputStream);
    }

    public OutputWriter(Writer writer) {
        out = new PrintWriter(writer);
    }

    /* PrintWriter methods */

    public void close() {
        out.close();
    }

    public void println(double x) {
        out.println(x);
    }

    /* My helper methods */

    }

import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Math.max;
import static java.lang.System.exit;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	static void solve() throws Exception {
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		while (tux-- > 0) {
			int pur = nextInt();
			foo += pur;
			++bar;
			if (foo * quz >= bar * baz) {
				baz = foo;
				quz = bar;
			}
		}
		out.print((double) baz / quz);
	}

	static int nextInt() throws IOException {
		return parseInt(next());
	}

	static long nextLong() throws IOException {
		return parseLong(next());
	}

	static double nextDouble() throws IOException {
		return parseDouble(next());
	}

	static String next() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}

import java.text.DecimalFormat;
import java.util.Scanner;

public class C1 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Scanner in = new Scanner(System.in);
  int tux = in.nextInt();
  int foo = 0;
  int bar = 0;
  int baz = 0;
  int quz = 1;
  for(;tux!=0;tux--) {
   int pur = in.nextInt();
   foo += pur;
   bar += 1;

   if(Math.max(foo*quz, bar*baz) == foo*quz){
    baz = foo;
    quz = bar;
   }
  }
  DecimalFormat df = new DecimalFormat("0.######");
  System.out.println(df.format(baz/(double)quz));
 }
}

import java.io.*;
import java.util.*;

public class C {

	void solve() throws IOException {
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 0;
		for (int i =0; i<tux; i++) {
			int pur = nextInt();
			foo +=pur;
			bar++;
			if (foo*quz>=bar*baz) {
				baz = foo;
				quz = bar;
			}
		}
		out.println(1.0*baz/quz);
	}

	void run() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new C().run();
	}

	BufferedReader br;
	PrintWriter out;
	StringTokenizer str;

	String next() throws IOException {
		while (str == null || !str.hasMoreTokens()) {
			str = new StringTokenizer(br.readLine());
		}
		return str.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

}

import java.util.*; //Scanner;
import java.io.PrintWriter; //PrintWriter

public class R176_AprilFool_C //Name: WTF?
{
	public static void main(String[] args) {
		Scanner      in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		solve(in, out);
		out.close();
		in.close();
	}

	public static void solve(Scanner in, PrintWriter out)
	{
		int tux = in.nextInt();
        int foo = 0, bar = 0, baz = 0, quz = 1;
        while (tux != 0)
        {
            int pur = in.nextInt();
            foo += pur;
            bar++;
            if (foo * quz > bar * baz)
            {
                baz = foo;
                quz = bar;
            }
            tux--;
        }
        out.println((double) baz / (double)quz);
	}
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class c {
    void do_solve() {
        int  tux = nextInt();

        long foo = 0;
        long bar = 0;
        long baz = 0;
        long quz = 1;

        while (tux != 0) {
            int pur = nextInt();
            foo += pur;
            bar += 1;

            if ( Math.max(foo * quz, bar * baz ) == foo * quz ) {
                baz = foo;
                quz = bar;
            }
            tux--;

        //  debug(foo, bar, baz, quz, pur);
        }
        //baz = nextInt();
        out.println(baz / (double)quz);
    }

    void mainProgram() {
        init(null);
        int test = 0;
        long T = System.currentTimeMillis();
        do_solve();
        System.err.println("Time on test " + (test++) + ": "
                + (System.currentTimeMillis() - T) + " ms");
        out.close();
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }

    void init(String filename) {
        Locale.setDefault(Locale.US);
        if (filename != null)
            try {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            } catch (Exception e) {
                e.printStackTrace();
                filename = null;
            }
        if (filename == null) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        st = new StringTokenizer("");
    }

    static BufferedReader in;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;
    static long systemTime;

    public static void main(String[] args) {
        try {
            setTime();
            new c().mainProgram();
            printTime();
            printMemory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    boolean hasMoreTokens() {
        try {
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(in.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return st.hasMoreTokens();
    }

    String nextToken() {
        return hasMoreTokens() ? st.nextToken() : null;
    }

    Integer nextInt() {
        return Integer.parseInt(nextToken());
    }

    Double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    Long nextLong() {
        return Long.parseLong(nextToken());
    }

    BigInteger add(BigInteger A, BigInteger B) {
        return A.add(B);
    }

    BigInteger mult(BigInteger A, BigInteger B) {
        return A.multiply(B);
    }

    BigInteger sub(BigInteger A, BigInteger B) {
        return A.subtract(B);
    }

    BigInteger div(BigInteger A, BigInteger B) {
        return A.divide(B);
    }

    BigInteger mi(BigInteger A) {
        return (BigInteger.ZERO).subtract(A);
    }

    BigInteger sq(BigInteger A) {
        return A.multiply(A);
    }

    BigInteger val(long a) {
        return BigInteger.valueOf(a);
    }

    int cmp(BigInteger a, BigInteger b) {
        return a.compareTo(b);
    }

    BigInteger gcd(BigInteger a, BigInteger b) {
        if (cmp(a, val(0)) < 0)
            a = mi(a);
        if (cmp(b, val(0)) < 0)
            b = mi(b);
        return a.gcd(b);
    }
}

import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);

		int tux = sc.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (; tux > 0; tux--) {
			int pur = sc.nextInt();

			foo += pur;
			bar++;

			if (Math.max(foo * quz, bar * baz) == foo * quz) {
				baz = foo;
				quz = bar;
			}
		}

		out.println(baz * 1.0 / quz);

		sc.close();
		out.close();
	}
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

    public void solve() throws Exception {
        int TUX = sc.nextInt();
        int FOO = 0;
        int BAR = 0;
        int BAZ = 0;
        int QUZ = 1;
        while (TUX > 0) {
            int PUR = sc.nextInt();
            FOO = FOO + PUR;
            BAR++;
            if (max(FOO * QUZ, BAR * BAZ) == FOO * QUZ) {
                BAZ = FOO;
                QUZ = BAR;
            }
            TUX--;
        }
        out.printf(Locale.US, "%.12f\n", (double)BAZ / QUZ);
    }

    static Throwable uncaught;

    BufferedReader in;
    FastScanner sc;
    PrintWriter out;

    @Override
    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
            sc = new FastScanner(in);
            solve();
        } catch (Throwable uncaught) {
            Solution.uncaught = uncaught;
        } finally {
            out.close();
        }
    }

    public static void main(String[] args) throws Throwable {
        Thread thread = new Thread(null, new Solution(), "", (1 << 26));
        thread.start();
        thread.join();
        if (Solution.uncaught != null) {
            throw Solution.uncaught;
        }
    }

}

class FastScanner {

    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }

}

import java.io.*;
import java.util.*;

public class C {

	FastScanner in;
	PrintWriter out;
	final String fileName = "С".toLowerCase();

	void solve() {
		int n = in.nextInt();
		double sum = 0;
		double max = 0;
		for (int i = 0; i < n; i++) {
			sum += in.nextDouble();
			max = Math.max(max, sum / (i + 1));
		}
		out.println(max);
	}

	void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);
			solve();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] args) {
		new C().run();
	}
}

import java.util.*;
public class C {
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
													// HAI
		int TUX;        							// I HAS A TUX
		TUX=in.nextInt();   						// GIMMEH TUX
		int FOO=0;									//I HAS A FOO ITS 0
		int BAR=0;									//I HAS A BAR ITS 0
		int BAZ=0;									//I HAS A BAZ ITS 0
		int QUZ=1;									//I HAS A QUZ ITS 1
													//TUX IS NOW A NUMBR
		for(;TUX!=0;TUX--){ 						//IM IN YR LOOP NERFIN YR TUX TIL BOTH SAEM TUX AN 0
			int PUR;								//I HAS A PUR
			PUR=in.nextInt();						//GIMMEH PUR
													//PUR IS NOW A NUMBR
			FOO+=PUR;								//FOO R SUM OF FOO AN PUR
			BAR++;									//BAR R SUM OF BAR AN 1
			if(FOO*QUZ>=BAR*BAZ){
													//O RLY?
													//YA RLY
				BAZ=FOO;							//BAZ R FOO
				QUZ=BAR;							//QUZ R BAR
			}
													//OIC
		}											//IM OUTTA YR LOOP
													//BAZ IS NOW A NUMBAR
		System.out.println((double)BAZ/QUZ);				//VISIBLE SMOOSH QUOSHUNT OF BAZ QUZ
													//KTHXBYE
	}

}

import java.util.Scanner;

public class Problem290C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tux = in.nextInt();
        double foo = 0;
        double bar = 0;
        double baz = 0;
        double quz = 1;
        for (int i = 0; i < tux; i++) {
            double pur = in.nextDouble();
            foo += pur;
            bar++;
            if (foo*quz >= bar*baz){
                baz = foo;
                quz = bar;
            }
        }
        System.out.printf("%.10f", baz / quz);
    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Sunits789
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int t=in.nextInt();
        double foo=0;
        double bar=0;
        double baz=0;
        double quz=0;
        for(int i=0;i<t;i++){
            double p=in.nextDouble();
            foo=foo+p;
            bar=bar+1;
            if(Math.max(foo*quz,bar*baz)==(foo*quz)){
                baz=foo;
                quz=bar;
            }
        }
        out.println(baz/quz);
    }
}

class InputReader{
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream){
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }
    public String next(){
        while (tokenizer == null||!tokenizer.hasMoreTokens()){
            try{
                tokenizer = new StringTokenizer(reader.readLine());
            }
            catch (IOException e){
                throw new RuntimeException(e);
            }

            catch (NullPointerException e){
                throw new UnknownError();
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt(){
        return Integer.parseInt(next());
    }

    public double nextDouble(){
        return Double.parseDouble(next());
    }

    }

import java.io.*;
import java.math.*;
import java.util.*;

public class c {
  public static void main(String[] args) throws Throwable {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    int tux = Integer.parseInt(in.readLine());
    int foo = 0, bar = 0, baz = 0, quz = 1;
    for (int i = tux; i > 0; i--) {
      int pur = Integer.parseInt(in.readLine());
      foo += pur;
      bar++;
      if (foo * quz >= bar * baz) {
        baz = foo;
        quz = bar;
      }
    }
    System.out.println(baz * 1.0 / quz);
  }
}

import java.util.Scanner;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigDecimal;
import java.io.BufferedWriter;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Fish <lyhypacm@gmail.com>
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskC solver = new TaskC();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskC {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int n = in.nextInt();
        int foo = 0, bar = 0, baz = 0, quz = 1;
        for (int i = 0; i < n; ++i) {
            int pur = in.nextInt();
            foo += pur;
            ++bar;
            if (foo * quz >= bar * baz) {
                baz = foo;
                quz = bar;
            } else break;
        }
        out.println(1.0 * baz / quz);
    }
}

class InputReader {
    private Scanner scanner;

    public InputReader(InputStream inputStream) {
        scanner = new Scanner(new BufferedReader(new InputStreamReader(inputStream)));
    }

    public int nextInt() {
        return scanner.nextInt();
    }

    public long nextLong() {
        return scanner.nextLong();
    }

    public String next() {
        return scanner.next();
    }

    public BigInteger nextBigInteger() {
        return scanner.nextBigInteger();
    }

    public BigDecimal nextBigDecimal() {
        return scanner.nextBigDecimal();
    }

    public double nextDouble() {
        return scanner.nextDouble();
    }
}

class OutputWriter {
    private PrintWriter printWriter;

    public OutputWriter(OutputStream outputStream) {
        printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        printWriter = new PrintWriter(writer);
    }

    public <T> void print(T object) {
        printWriter.print(object);
    }

    public <T> void println(T object) {
        printWriter.println(object);
    }

    public void println() {
        printWriter.println();
    }

    public void close() {
        printWriter.close();
    }
}

import java.io.*;
import java.util.*;

public class C {
	public static void main(String[] args) {
		new C().run();
	}

	BufferedReader br;
	StringTokenizer in;
	PrintWriter out;

	public String nextToken() throws IOException {
		while (in == null || !in.hasMoreTokens()) {
			in = new StringTokenizer(br.readLine());
		}
		return in.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public void solve() throws IOException {
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		while (tux-- != 0) {
			int pur = nextInt();
			foo += pur;
			bar++;
			if (Math.max(foo * quz, bar * baz) == foo * quz) {
				baz = foo;
				quz = bar;
			}
		}
		out.println(1. * baz / quz);
	}

	public void run() {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class MainC {

    FastScanner in;
    PrintWriter out;

    public void solve() throws IOException {
        int tux = in.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        for (int i = 0; i < tux; i++) {
            int pur = in.nextInt();
            foo = foo + pur;
            bar++;
            if (foo * quz >= bar * baz) {
                baz = foo;
                quz = bar;
            }
        }
        double b = baz;
        b /= quz;
        System.out.format("%.8f", b);
    }

    public void run() {
        try {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
            solve();
            out.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public static void main(String[] arg) {
        new MainC().run();
    }
}

import java.io.*;
import java.util.*;

public class C {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	void solve() throws IOException {
		double ans = 0;
		int n = nextInt();
		for (int i = 1, sum = 0; i <= n; i++) {
			int x = nextInt();
			sum += x;
			ans = Math.max(ans, 1.0 * sum / i);
		}
		out.printf("%.12f\n", ans);
	}

	C() throws IOException {
		Locale.setDefault(Locale.US);
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new C();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class C {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int TUX = Integer.parseInt(br.readLine());
		int FOO=0,BAR=0,BAZ=0,QUZ=1;
		for (int i = 0; i < TUX; i++) {
			int PUR = Integer.parseInt(br.readLine());
			FOO += PUR;
			BAR++;
			if(FOO*QUZ>=BAR*BAZ){
				BAZ = FOO;
				QUZ = BAR;
			}
		}
		System.out.println(Math.round((1.0*BAZ/QUZ)*1000000)/1000000.0);
	}
}

/* Codeforces Template */

import java.io.*;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.fill;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.sort;

public class Main {

	static long initTime;
	static final Random rnd = new Random(7777L);
	static boolean writeLog = false;

	public static void main(String[] args) throws IOException {
		initTime = System.currentTimeMillis();
		try {
			writeLog = "true".equals(System.getProperty("LOCAL_RUN_7777"));
		} catch (SecurityException e) {}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					try {
						if (new File("input.txt").exists())
							System.setIn(new FileInputStream("input.txt"));
					} catch (SecurityException e) {}
					long prevTime = System.currentTimeMillis();
					new Main().run();
					log("Total time: " + (System.currentTimeMillis() - prevTime) + " ms");
					log("Memory status: " + memoryStatus());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, "1", 1L << 24).start();
	}

	void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
		in.close();
	}

	/***************************************************************
	 * Solution
	 **************************************************************/

	void solve() throws IOException  {

		int tux = nextInt();

		long foo = 0;
		long bar = 0;
		long baz = 0;
		long quz = 1;

		for (; tux != 0; tux--) {

			int pur = nextInt();

			foo += pur;
			bar += 1L;

			if (max(foo * quz, bar * baz) ==  foo * quz) {
				baz = foo;
				quz = bar;
			}
		}

		double ans = baz / (double) quz;
		out.printf(Locale.US, "%.12f%n", ans);

	}

	/***************************************************************
	 * Input
	 **************************************************************/
	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	int[] nextIntArray(int size) throws IOException {
		int[] ret = new int [size];
		for (int i = 0; i < size; i++)
			ret[i] = nextInt();
		return ret;
	}

	long[] nextLongArray(int size) throws IOException {
		long[] ret = new long [size];
		for (int i = 0; i < size; i++)
			ret[i] = nextLong();
		return ret;
	}

	double[] nextDoubleArray(int size) throws IOException {
		double[] ret = new double [size];
		for (int i = 0; i < size; i++)
			ret[i] = nextDouble();
		return ret;
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}

	/***************************************************************
	 * Output
	 **************************************************************/
	void printRepeat(String s, int count) {
		for (int i = 0; i < count; i++)
			out.print(s);
	}

	void printArray(int[] array) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			if (i > 0) out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(long[] array) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			if (i > 0) out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(double[] array) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			if (i > 0) out.print(' ');
			out.print(array[i]);
		}
		out.println();
	}

	void printArray(double[] array, String spec) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			if (i > 0) out.print(' ');
			out.printf(Locale.US, spec, array[i]);
		}
		out.println();
	}

	void printArray(Object[] array) {
		if (array == null || array.length == 0)
			return;
		boolean blank = false;
		for (Object x : array) {
			if (blank) out.print(' '); else blank = true;
			out.print(x);
		}
		out.println();
	}

	@SuppressWarnings("rawtypes")
	void printCollection(Collection collection) {
		if (collection == null || collection.isEmpty())
			return;
		boolean blank = false;
		for (Object x : collection) {
			if (blank) out.print(' '); else blank = true;
			out.print(x);
		}
		out.println();
	}

	/***************************************************************
	 * Utility
	 **************************************************************/
	static String memoryStatus() {
		return (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory() >> 20) + "/" + (Runtime.getRuntime().totalMemory() >> 20) + " MB";
	}

	static void checkMemory() {
		System.err.println(memoryStatus());
	}

	static long prevTimeStamp = Long.MIN_VALUE;

	static void updateTimer() {
		prevTimeStamp = System.currentTimeMillis();
	}

	static long elapsedTime() {
		return (System.currentTimeMillis() - prevTimeStamp);
	}

	static void checkTimer() {
		System.err.println(elapsedTime() + " ms");
	}

	static void chk(boolean f) {
		if (!f) throw new RuntimeException("Assert failed");
	}

	static void chk(boolean f, String format, Object ... args) {
		if (!f) throw new RuntimeException(String.format(format, args));
	}

	static void log(String format, Object ... args) {
		if (writeLog) System.err.println(String.format(Locale.US, format, args));
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class A3 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int TUX = Integer.parseInt(br.readLine());
        int FOO = 0;
        int BAR = 0;
        int BAZ = 0;
        int QUZ = 1;
        for(int i = 0; i < TUX; i++) {
            int PUR = Integer.parseInt(br.readLine());
            FOO = FOO + PUR;
            BAR = BAR + 1;
            if(FOO * QUZ >= BAR * BAZ) {
                BAZ = FOO;
                QUZ = BAR;
            }
        }
        System.out.println(1.0 * BAZ / QUZ);
    }
}

import java.util.Scanner;

public class B {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt();
		double a = 0, b = t;
		while (t-- > 0) {
			int n = sc.nextInt();
			if(n == 1) {
				a++;
			}
		}
		System.out.println(a / b);
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        c290 solver = new c290();
        solver.solve(1, in, out);
        out.close();
    }

    static class c290 {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum += in.nextInt();
            }
            out.println((double) sum / n);
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String next() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main implements Runnable {

	private void solve() throws IOException {
		int tux = nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (int i = 0; i < tux; ++i) {
			int pur = nextInt();
			foo += pur;
			++bar;
			if (true) {
				baz = foo;
				quz = bar;
			}
		}

		out.println((baz + .0) / quz);
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String line = in.readLine();
			if (line == null)
				return null;
			eat(line);
		}
		return st.nextToken();
	}

	public static void main(String[] args) {
		new Thread(null, new Main(), "Main", 1 << 28).start();
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			eat("");
			solve();
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(566);
		}
	}

	private void eat(String s) {
		st = new StringTokenizer(s);
	}

}

import java.util.Scanner;
public class WTF {
	public static void main(String[] args) {
		Scanner in = new Scanner (System.in);
		int n = in.nextInt();
		int max =0;
		for(int i=0;i<n;i++)
			if(in.nextInt()!=0)
				max++;
		System.out.printf("%.6f\n",(double)max/n);
	}
}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class C implements Runnable {

    /*
    for
     foo := foo + pur
     bar := bar + 1
     ?  foo * quz,  bar * baz,  foo * quz
      baz := foo
      quz := bar

    baz / quz
     */

    public void solve() throws IOException {
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        int tux = in.nextInt();
        for ( int i = 0; i < tux; i ++ ) {
            int pur = in.nextInt();
            foo += pur;
            bar += 1;

            baz = foo;
            quz = bar;
        }
        out.println( 1.0 * baz / quz );
    }

    public Scanner in;

    public PrintWriter out;

    C() throws IOException {
        in = new Scanner(System.in);
        // in = new StreamTokenizer( new InputStreamReader( System.in ) );
        out = new PrintWriter(System.out);
    }

//    int nextInt() throws IOException {
//        in.nextToken();
//        return ( int ) in.nval;
//    }

    void check(boolean f, String msg) {
        if (!f) {
            out.close();
            throw new RuntimeException(msg);
        }
    }

    void close() throws IOException {
        out.close();
    }

    public void run() {
        try {
            solve();
            close();
        } catch (Exception e) {
            e.printStackTrace(out);
            out.flush();
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        new Thread(new C()).start();
    }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class Solver {

	public static void main(String[] Args) throws NumberFormatException,
			IOException {
		new Solver().Run();
	}

	PrintWriter pw;
	StringTokenizer Stok;
	BufferedReader br;

	public String nextToken() throws IOException {
		while (Stok == null || !Stok.hasMoreTokens()) {
			Stok = new StringTokenizer(br.readLine());
		}
		return Stok.nextToken();
	}

	public int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextToken());
	}

	public long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(nextToken());
	}

	public void Run() throws NumberFormatException, IOException {
		//br = new BufferedReader(new FileReader("input.txt"));
		//pw = new PrintWriter("output.txt");
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new OutputStreamWriter(System.out));
		int TUX = nextInt(), FOO = 0 , BAR = 0;
		int PUR;
		for (;TUX>0;TUX--){
			PUR = nextInt();
			FOO += PUR;
			BAR++;
		}
		float res = FOO;
		pw.print(res/BAR);
		pw.flush();
		pw.close();
	}

}

//package afc2013;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class C {
	InputStream is;
	PrintWriter out;
	String INPUT = "3 0 1 1";

	void solve()
	{
		int n = ni();
		int f = 0, r = 0, z = 0, q = 1;
		for(int i = 0;i < n;i++){
			int p = ni();
			f += p;
			r++;
			if(Math.max(f*q, r*z) >= f*q){
				z = f;
				q = r;
			}
		}
		out.printf("%.9f\n", (double)z/q);
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new C().run(); }

	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import static java.util.Collections.*;
import java.io.*;

public class _290_C_WTF {

	public void solve() {
		int tux = ni();
		int d=0;
		int foo=0;
		int bar=0;
		int baz=0;
		int quz=1;
		for (int i = 0; i < tux; i++) {
			int pur = ni();
			foo+=pur;
			bar++;
			pr(foo,bar,baz,quz,foo*quz,bar*baz);
//			if(foo*quz==bar*baz){
//
//			}
			baz=foo;
			quz=bar;

		}
		out.println(baz/(double)quz);
	}

	// IO methods

	void run() throws Exception {
		long s = System.currentTimeMillis();
		solve();
		out.flush();
		pr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception {
		new _290_C_WTF().run();
	}

	InputStream in = System.in;
	PrintWriter out = new PrintWriter(System.out);

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = in.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	public String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != //
									// ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	public char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	public int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	public long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	void pr(Object... ob) {
		if (!oj)
			System.out.println(Arrays.deepToString(ob).replace("],", "],\n"));
	}
}

import java.util.*;
import java.util.regex.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.lang.Integer.*;
import static java.lang.Double.*;
import static java.util.Collections.*;
import java.io.*;

public class _290_C_WTF {

	public void solve() {
		int n = ni();
		int d=0;
		for (int i = 0; i < n; i++) {
			d+=ni();
		}
		out.println(d/(double)n);
	}

	// IO methods

	void run() throws Exception {
		long s = System.currentTimeMillis();
		solve();
		out.flush();
		pr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception {
		new _290_C_WTF().run();
	}

	InputStream in = System.in;
	PrintWriter out = new PrintWriter(System.out);

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = in.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}

	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	public String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != //
									// ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	public char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	public int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	public long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	void pr(Object... ob) {
		if (!oj)
			System.out.println(Arrays.deepToString(ob).replace("],", "],\n"));
	}
}

import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Saul
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskC {
  public void solve(int testNumber, Scanner in, PrintWriter out) {
    int n = in.nextInt();
    double ans = 0;
    for (int i = 0; i < n; i++) {
      ans += in.nextInt();
    }
    out.print( ans / n );
  }
}

//package Round_FirstApril_2013;

import java.util.*;
import java.io.*;

import static java.lang.Math.*;

public class C {

    void solve () throws IOException {
        int n = in.nextInt();
        if (n == 0){
            out.println(0);
            return;
        }
        double sum = 0;
        for (int i = 0; i<n; i++)
            sum += in.nextDouble();
        out.println(sum / n);

    }

    String input = "";
    String output = "";

    FastScanner in;
    PrintWriter out;

    void run () {
        try {
            BufferedReader bf;
            if (input.length() == 0)
                bf = new BufferedReader(new InputStreamReader(
                        System.in));
            else
                bf = new BufferedReader(new FileReader(input));
            in = new FastScanner(bf);

            if (output.length() == 0)
                out = new PrintWriter(System.out);
            else
                out = new PrintWriter(new File(output));

            solve();

            out.close();
        } catch (Exception ex) {
            out.close();
            ex.printStackTrace();
        }
    }

    public static void main (String[] args) {
        new C().run();
    }

    class FastScanner {
        BufferedReader bf;
        StringTokenizer st;

        FastScanner(BufferedReader bf) {
            this.bf = bf;
        }

        String next () throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        int nextInt () throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong () throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble () throws IOException {
            return Double.parseDouble(next());
        }

        int[] readIntArray (int n) throws IOException {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        long[] readLongArray (int n) throws IOException {
            long a[] = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
    }
}

//package Round_FirstApril_2013;

import java.util.*;
import java.io.*;

import static java.lang.Math.*;

public class C {

    void solve () throws IOException {
        int n = in.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        for (int i = n; i>0; i--){
            int pur = in.nextInt();
            foo += pur;
            bar ++;
            if (foo * quz * bar >= baz * foo * quz){
                baz = foo;
                quz = bar;
            }
        }
        out.println (1.0 * baz / quz);

    }

    String input = "";
    String output = "";

    FastScanner in;
    PrintWriter out;

    void run () {
        try {
            BufferedReader bf;
            if (input.length() == 0)
                bf = new BufferedReader(new InputStreamReader(
                        System.in));
            else
                bf = new BufferedReader(new FileReader(input));
            in = new FastScanner(bf);

            if (output.length() == 0)
                out = new PrintWriter(System.out);
            else
                out = new PrintWriter(new File(output));

            solve();

            out.close();
        } catch (Exception ex) {
            out.close();
            ex.printStackTrace();
        }
    }

    public static void main (String[] args) {
        new C().run();
    }

    class FastScanner {
        BufferedReader bf;
        StringTokenizer st;

        FastScanner(BufferedReader bf) {
            this.bf = bf;
        }

        String next () throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        int nextInt () throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong () throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble () throws IOException {
            return Double.parseDouble(next());
        }

        int[] readIntArray (int n) throws IOException {
            int a[] = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        long[] readLongArray (int n) throws IOException {
            long a[] = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
    }
}

//package Round_FirstApril_2013;

import java.util.*;
import java.io.*;

import static java.lang.Math.*;

public class C {

	void solve () throws IOException {
		int n = in.nextInt();
		if (n == 0){
			out.println(0.0);
			return;
		}
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (int i = n; i>0; i--){
			int pur = in.nextInt();
			foo += pur;
			bar ++;
			if (foo * quz * bar  > baz * foo * quz){
				baz = foo;
				quz = bar;
			}
		}
		out.println (1.0 * baz / quz);

	}

	String input = "";
	String output = "";

	FastScanner in;
	PrintWriter out;

	void run () {
		try {
			BufferedReader bf;
			if (input.length() == 0)
				bf = new BufferedReader(new InputStreamReader(
						System.in));
			else
				bf = new BufferedReader(new FileReader(input));
			in = new FastScanner(bf);

			if (output.length() == 0)
				out = new PrintWriter(System.out);
			else
				out = new PrintWriter(new File(output));

			solve();

			out.close();
		} catch (Exception ex) {
			out.close();
			ex.printStackTrace();
		}
	}

	public static void main (String[] args) {
		new C().run();
	}

	class FastScanner {
		BufferedReader bf;
		StringTokenizer st;

		FastScanner(BufferedReader bf) {
			this.bf = bf;
		}

		String next () throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(bf.readLine());
			return st.nextToken();
		}

		int nextInt () throws IOException {
			return Integer.parseInt(next());
		}

		long nextLong () throws IOException {
			return Long.parseLong(next());
		}

		double nextDouble () throws IOException {
			return Double.parseDouble(next());
		}

		int[] readIntArray (int n) throws IOException {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		long[] readLongArray (int n) throws IOException {
			long a[] = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}
	}
}

import static java.lang.Math.*;
import static java.lang.System.currentTimeMillis;
import static java.lang.System.exit;
import static java.lang.System.arraycopy;
import static java.util.Arrays.sort;
import static java.util.Arrays.binarySearch;
import static java.util.Arrays.fill;
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) throws IOException {
		try {
			if (new File("input.txt").exists())
				System.setIn(new FileInputStream("input.txt"));
		} catch (SecurityException e) {
		}
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main().run();
				} catch (Throwable e) {
					e.printStackTrace();
					exit(999);
				}
			}
		}, "1", 1 << 23).start();
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer st = new StringTokenizer("");

	private void run() throws IOException {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		in.close();
		out.close();
	}

	private void solve() throws IOException {
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		int n = nextInt();
		for (int i = 0; i < n; i++) {
			int pur = nextInt();
			foo += pur;
			bar++;
			baz = foo;
			quz = bar;
		}
		out.println(1. * baz / quz);
	}

	void chk(boolean b) {
		if (b)
			return;
		System.out.println(new Error().getStackTrace()[1]);
		exit(999);
	}
	void deb(String fmt, Object... args) {
		System.out.printf(Locale.US, fmt + "%n", args);
	}
	String nextToken() throws IOException {
		while (!st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}
	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}
	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}
	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}
	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String s = in.readLine();
			if (s == null)
				return true;
			st = new StringTokenizer(s);
		}
		return false;
	}
}

import java.io.*;
import java.util.*;

public class FirstApril {
    FastScanner in;
    PrintWriter out;

    void solve() {
        int n = in.nextInt();
        double sum = 0;
        for (int i = 0; i < n; i++) {
            sum += in.nextInt() / (n + 0.);
        }
        out.println(sum);
    }

    void run() {
        try {
            in = new FastScanner(new File("object.in"));
            out = new PrintWriter(new File("object.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }
    }

    public static void main(String[] args) {
        new FirstApril().runIO();
    }
}

import java.io.*;
import java.util.*;

public class FirstApril {
    FastScanner in;
    PrintWriter out;

    void solve() {
        int n = in.nextInt();
        if (n == 1) {
            out.println(0);
            return;
        }
        int sum = 0;
        double max = 0;
        for (int i = 0; i < n; i++) {
            sum += in.nextInt();
            max = Math.max(sum / (1. + i), max);
        }
        out.println(max);
        /*String s = in.next();
        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == 'H') {
                sum += 12;
            } else {
                sum += s.length();
            }
        }
        out.println(sum % 2==0 ? "" : "");
        */
    }

    void run() {
        try {
            in = new FastScanner(new File("object.in"));
            out = new PrintWriter(new File("object.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }
    }

    public static void main(String[] args) {
        new FirstApril().runIO();
    }
}

import java.io.*;
import java.util.*;

public class FirstApril {
    FastScanner in;
    PrintWriter out;

    void solve() {
        int n = in.nextInt();
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += in.nextInt();
        }
        out.println(sum / (n + 0.));
    }

    void run() {
        try {
            in = new FastScanner(new File("object.in"));
            out = new PrintWriter(new File("object.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }
    }

    public static void main(String[] args) {
        new FirstApril().runIO();
    }
}

import java.util.*;
import java.math.*;
import java.io.*;

public class Solurion {

	private void solve() throws Exception {
		int n = nextInt();
		double sum = 0;
		for (int i = 0; i < n; ++i) {
			sum += nextInt();
		}
		out.println(sum / n);
	}

	public void run() {
		try {
			solve();
		} catch (Exception e) {
			NOO(e);
		} finally {
			out.close();
		}
	}

	PrintWriter out;
	BufferedReader in;
	StringTokenizer St;

	void NOO(Exception e) {
		e.printStackTrace();
		System.exit(42);
	}

	int nextInt() {
		return Integer.parseInt(nextToken());
	}

	long nextLong() {
		return Long.parseLong(nextToken());
	}

	double nextDouble() {
		return Double.parseDouble(nextToken());
	}

	String nextToken() {
		while (!St.hasMoreTokens()) {
			try {
				String line = in.readLine();
				if (line == null)
					return null;
				St = new StringTokenizer(line);
			} catch (Exception e) {
				NOO(e);
			}
		}
		return St.nextToken();
	}

	private Solurion(String name) {
		try {
			in = new BufferedReader(new FileReader("input.txt"));
			St = new StringTokenizer("");
			out = new PrintWriter(new FileWriter("output.txt"));
		} catch (Exception e) {
			NOO(e);
		}
	}

	private Solurion() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			St = new StringTokenizer("");
			out = new PrintWriter(System.out);
		} catch (Exception e) {
			NOO(e);
		}
	}

	public static void main(String[] args) {
		//Locale.setDefault(Locale.US);
		new Solurion().run();
	}
}

import java.io.*;
import java.util.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

	public void solve () throws Throwable {
		int n = sc.nextInt();
		double sum = 0.0;
		for (int i = 0; i < n; i++) {
			sum += sc.nextDouble();
		}
		out.printf("%.4f", sum / n);
	}

	BufferedReader in;
	PrintWriter out;
	FastScanner sc;

	static Throwable uncaught;

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			sc = new FastScanner(in);
			solve();
		} catch (Throwable t) {
			Solution.uncaught = t;
		} finally {
			out.close();
		}
	}

	public static void main(String[] args) throws Throwable {
		Thread t = new Thread(null, new Solution(), "", (1 << 26));
		t.start();
		t.join();
		if (uncaught != null) {
			throw uncaught;
		}
	}

}

class FastScanner {

	BufferedReader reader;
	StringTokenizer strTok;

	public FastScanner(BufferedReader reader) {
		this.reader = reader;
	}

	public String nextToken() throws IOException {
		while (strTok == null || !strTok.hasMoreTokens()) {
			strTok = new StringTokenizer(reader.readLine().trim());
		}
		return strTok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

}

import java.io.*;
import java.util.*;
import java.math.*;
import java.awt.geom.*;

import static java.lang.Math.*;

public class Solution implements Runnable {

	public void solve () throws Throwable {
		int n = sc.nextInt();
		if (n == 0) {
			out.println("0.0000");
			return;
		}
		double sum = 0.0;
		for (int i = 0; i < n; i++) {
			sum += sc.nextInt();
		}

		out.printf("%.6f", sum / n);
	}

	BufferedReader in;
	PrintWriter out;
	FastScanner sc;

	static Throwable uncaught;

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			sc = new FastScanner(in);
			solve();
		} catch (Throwable t) {
			Solution.uncaught = t;
		} finally {
			out.close();
		}
	}

	public static void main(String[] args) throws Throwable {
		Thread t = new Thread(null, new Solution(), "", (1 << 26));
		t.start();
		t.join();
		if (uncaught != null) {
			throw uncaught;
		}
	}

}

class FastScanner {

	BufferedReader reader;
	StringTokenizer strTok;

	public FastScanner(BufferedReader reader) {
		this.reader = reader;
	}

	public String nextToken() throws IOException {
		while (strTok == null || !strTok.hasMoreTokens()) {
			strTok = new StringTokenizer(reader.readLine().trim());
		}
		return strTok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

}

import java.util.Scanner;
import java.io.*;

// The "ProblemC" class.
public class ProblemC
{
    public static void main (String[] args) throws IOException
    {
		//Scanner inFile = new Scanner(new File("DATA_C.txt"));
		Scanner inSys = new Scanner(System.in);
		//PrintStream outFile = new PrintStream(new File("OUT_C.txt"));
		PrintStream outSys = new PrintStream(System.out);

		//int numloops = Integer.parseInt(inFile.nextLine());
		int numloops = Integer.parseInt(inSys.nextLine());
		int sum = 0;

		for(int i = 0; i < numloops; i++)
		{
			//sum = sum + Integer.parseInt(inFile.nextLine());
			sum = sum + Integer.parseInt(inSys.nextLine());
		}

		System.out.println(1.0 * sum / numloops);
    } // main method
} // ProblemC class

import java.io.*;
import java.util.*;

public class Solution {
    public static void main (String[] args) throws IOException {
        boolean online = "true".equals(System.getProperty("ONLINE_JUDGE"));
        if (online) {
            in = new InputReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        else {
            in = new InputReader(new FileReader("input.txt"));
            out = new PrintWriter(new File("output.txt"));
        }

        new Solution().run();

        out.close();
    }

    private void run () {
        int n = in.nextInt();
        double sum = 0;
        int k = 0;
        for (int i = 0; i < n; ++i) {
            sum += in.nextInt();
            ++k;
        }
        out.println(sum/k);
    }

    private static InputReader in;
    private static PrintWriter out;
}

class InputReader {
    public InputReader (Reader r) {
        buff = new BufferedReader(r);
        try {
            str = new StringTokenizer(buff.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String next () {
        while (!str.hasMoreTokens())
            try {
                str = new StringTokenizer(buff.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        return str.nextToken();
    }

    public int nextInt () {
        return Integer.parseInt(this.next());
    }

    public long nextLong () {
        return Long.parseLong(this.next());
    }

    private static BufferedReader buff;
    private static StringTokenizer str;
}

import java.util.Scanner;

public class C1 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Scanner in = new Scanner(System.in);
  int tux = in.nextInt();
  int foo = 0;
  int bar = 0;
  int baz = 0;
  int quz = 1;
  for(;tux!=0;tux--) {
   int pur = in.nextInt();
   foo += pur;
   bar += 1;
   if((foo*quz*bar)>=(baz*foo*quz)) {
    baz = foo;
    quz = bar;
   }
  }
  System.out.println(baz/(float)quz);
 }
}

import java.io.*;
import java.util.*;

public class C {

	void solve() throws IOException {
		int n = nextInt();
		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum+=nextInt();
		}
		out.println(sum/(double)n);
	}

	void run() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new C().run();
	}

	BufferedReader br;
	PrintWriter out;
	StringTokenizer str;

	String next() throws IOException {
		while (str == null || !str.hasMoreTokens()) {
			str = new StringTokenizer(br.readLine());
		}
		return str.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

}

import java.io.*;
import java.util.*;

public class C {

	void solve() throws IOException {
		int n = nextInt();
		if (n ==0){
			throw new AssertionError();
		}
		int sum = 0;
		for (int i = 0; i < n; i++) {
			sum+=nextInt();
		}
		out.println(sum/(double)n);
	}

	void run() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new C().run();
	}

	BufferedReader br;
	PrintWriter out;
	StringTokenizer str;

	String next() throws IOException {
		while (str == null || !str.hasMoreTokens()) {
			str = new StringTokenizer(br.readLine());
		}
		return str.nextToken();
	}

	int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}

	long nextLong() throws IOException {
		return Long.parseLong(next());
	}

}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class c {
    void do_solve() {
        int t = nextInt();
        long foo = 0;
        long bar = 0;
        long baz = 0;
        long quz = 1;

        while (t > 0) {
            int pur = nextInt();
            foo += pur;
            bar += 1;

            if (foo * quz * bar > foo * quz * baz) {
                baz = foo;
                quz = bar;
            }
            t--;

        //  debug(foo, bar, baz, quz, pur);
        }
        //baz = nextInt();
        out.println(baz / (double)quz);
    }

    void mainProgram() {
        init(null);
        int test = 0;
        long T = System.currentTimeMillis();
        do_solve();
        System.err.println("Time on test " + (test++) + ": "
                + (System.currentTimeMillis() - T) + " ms");
        out.close();
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }

    void init(String filename) {
        Locale.setDefault(Locale.US);
        if (filename != null)
            try {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            } catch (Exception e) {
                e.printStackTrace();
                filename = null;
            }
        if (filename == null) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        st = new StringTokenizer("");
    }

    static BufferedReader in;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;
    static long systemTime;

    public static void main(String[] args) {
        try {
            setTime();
            new c().mainProgram();
            printTime();
            printMemory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    boolean hasMoreTokens() {
        try {
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(in.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return st.hasMoreTokens();
    }

    String nextToken() {
        return hasMoreTokens() ? st.nextToken() : null;
    }

    Integer nextInt() {
        return Integer.parseInt(nextToken());
    }

    Double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    Long nextLong() {
        return Long.parseLong(nextToken());
    }

    BigInteger add(BigInteger A, BigInteger B) {
        return A.add(B);
    }

    BigInteger mult(BigInteger A, BigInteger B) {
        return A.multiply(B);
    }

    BigInteger sub(BigInteger A, BigInteger B) {
        return A.subtract(B);
    }

    BigInteger div(BigInteger A, BigInteger B) {
        return A.divide(B);
    }

    BigInteger mi(BigInteger A) {
        return (BigInteger.ZERO).subtract(A);
    }

    BigInteger sq(BigInteger A) {
        return A.multiply(A);
    }

    BigInteger val(long a) {
        return BigInteger.valueOf(a);
    }

    int cmp(BigInteger a, BigInteger b) {
        return a.compareTo(b);
    }

    BigInteger gcd(BigInteger a, BigInteger b) {
        if (cmp(a, val(0)) < 0)
            a = mi(a);
        if (cmp(b, val(0)) < 0)
            b = mi(b);
        return a.gcd(b);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class c {
    void do_solve() {
        int t = nextInt();
        long foo = 0;
        long bar = 0;
        long baz = 0;
        long quz = 1;

        while (t > 0) {
            int pur = nextInt();
            foo += pur;
            bar += 1;

            if ( bar > baz ) {
                baz = foo;
                quz = bar;
            }
            t--;

        //  debug(foo, bar, baz, quz, pur);
        }
        //baz = nextInt();
        out.println(baz / (double)quz);
    }

    void mainProgram() {
        init(null);
        int test = 0;
        long T = System.currentTimeMillis();
        do_solve();
        System.err.println("Time on test " + (test++) + ": "
                + (System.currentTimeMillis() - T) + " ms");
        out.close();
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }

    void init(String filename) {
        Locale.setDefault(Locale.US);
        if (filename != null)
            try {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            } catch (Exception e) {
                e.printStackTrace();
                filename = null;
            }
        if (filename == null) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        st = new StringTokenizer("");
    }

    static BufferedReader in;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;
    static long systemTime;

    public static void main(String[] args) {
        try {
            setTime();
            new c().mainProgram();
            printTime();
            printMemory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    boolean hasMoreTokens() {
        try {
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(in.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return st.hasMoreTokens();
    }

    String nextToken() {
        return hasMoreTokens() ? st.nextToken() : null;
    }

    Integer nextInt() {
        return Integer.parseInt(nextToken());
    }

    Double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    Long nextLong() {
        return Long.parseLong(nextToken());
    }

    BigInteger add(BigInteger A, BigInteger B) {
        return A.add(B);
    }

    BigInteger mult(BigInteger A, BigInteger B) {
        return A.multiply(B);
    }

    BigInteger sub(BigInteger A, BigInteger B) {
        return A.subtract(B);
    }

    BigInteger div(BigInteger A, BigInteger B) {
        return A.divide(B);
    }

    BigInteger mi(BigInteger A) {
        return (BigInteger.ZERO).subtract(A);
    }

    BigInteger sq(BigInteger A) {
        return A.multiply(A);
    }

    BigInteger val(long a) {
        return BigInteger.valueOf(a);
    }

    int cmp(BigInteger a, BigInteger b) {
        return a.compareTo(b);
    }

    BigInteger gcd(BigInteger a, BigInteger b) {
        if (cmp(a, val(0)) < 0)
            a = mi(a);
        if (cmp(b, val(0)) < 0)
            b = mi(b);
        return a.gcd(b);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class c {
    void do_solve() {
        int t = nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;

        while (t > 0) {
            int pur = nextInt();
            foo += pur;
            bar += 1;

            if (foo * quz * bar / (double) baz > foo * quz) {
                baz = foo;
                quz = bar;
            }
            t--;

        //  debug(foo, bar, baz, quz, pur);
        }
        //baz = nextInt();
        out.println(baz / (double)quz);
    }

    void mainProgram() {
        init(null);
        int test = 0;
        long T = System.currentTimeMillis();
        do_solve();
        System.err.println("Time on test " + (test++) + ": "
                + (System.currentTimeMillis() - T) + " ms");
        out.close();
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }

    void init(String filename) {
        Locale.setDefault(Locale.US);
        if (filename != null)
            try {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            } catch (Exception e) {
                e.printStackTrace();
                filename = null;
            }
        if (filename == null) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        st = new StringTokenizer("");
    }

    static BufferedReader in;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;
    static long systemTime;

    public static void main(String[] args) {
        try {
            setTime();
            new c().mainProgram();
            printTime();
            printMemory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    boolean hasMoreTokens() {
        try {
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(in.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return st.hasMoreTokens();
    }

    String nextToken() {
        return hasMoreTokens() ? st.nextToken() : null;
    }

    Integer nextInt() {
        return Integer.parseInt(nextToken());
    }

    Double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    Long nextLong() {
        return Long.parseLong(nextToken());
    }

    BigInteger add(BigInteger A, BigInteger B) {
        return A.add(B);
    }

    BigInteger mult(BigInteger A, BigInteger B) {
        return A.multiply(B);
    }

    BigInteger sub(BigInteger A, BigInteger B) {
        return A.subtract(B);
    }

    BigInteger div(BigInteger A, BigInteger B) {
        return A.divide(B);
    }

    BigInteger mi(BigInteger A) {
        return (BigInteger.ZERO).subtract(A);
    }

    BigInteger sq(BigInteger A) {
        return A.multiply(A);
    }

    BigInteger val(long a) {
        return BigInteger.valueOf(a);
    }

    int cmp(BigInteger a, BigInteger b) {
        return a.compareTo(b);
    }

    BigInteger gcd(BigInteger a, BigInteger b) {
        if (cmp(a, val(0)) < 0)
            a = mi(a);
        if (cmp(b, val(0)) < 0)
            b = mi(b);
        return a.gcd(b);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class c {
    void do_solve() {
        int  tux = nextInt();

        long foo = 0;
        long bar = 0;
        long baz = 0;
        long quz = 1;

        while (tux != 0) {
            int pur = nextInt();
            foo += pur;
            bar += 1;

            if ( bar != baz ) {
                baz = foo;
                quz = bar;
            }
            tux--;

        //  debug(foo, bar, baz, quz, pur);
        }
        //baz = nextInt();
        out.println(baz / (double)quz);
    }

    void mainProgram() {
        init(null);
        int test = 0;
        long T = System.currentTimeMillis();
        do_solve();
        System.err.println("Time on test " + (test++) + ": "
                + (System.currentTimeMillis() - T) + " ms");
        out.close();
    }

    static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }

    void init(String filename) {
        Locale.setDefault(Locale.US);
        if (filename != null)
            try {
                in = new BufferedReader(new FileReader(filename + ".in"));
                out = new PrintWriter(filename + ".out");
            } catch (Exception e) {
                e.printStackTrace();
                filename = null;
            }
        if (filename == null) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        }
        st = new StringTokenizer("");
    }

    static BufferedReader in;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;
    static long systemTime;

    public static void main(String[] args) {
        try {
            setTime();
            new c().mainProgram();
            printTime();
            printMemory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static void setTime() {
        systemTime = System.currentTimeMillis();
    }

    static void printTime() {
        System.err.println("Time consumed: "
                + (System.currentTimeMillis() - systemTime));
    }

    static void printMemory() {
        System.err.println("Memory consumed: "
                + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime()
                        .freeMemory()) / 1000 + "kb");
    }

    boolean hasMoreTokens() {
        try {
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(in.readLine());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return st.hasMoreTokens();
    }

    String nextToken() {
        return hasMoreTokens() ? st.nextToken() : null;
    }

    Integer nextInt() {
        return Integer.parseInt(nextToken());
    }

    Double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    Long nextLong() {
        return Long.parseLong(nextToken());
    }

    BigInteger add(BigInteger A, BigInteger B) {
        return A.add(B);
    }

    BigInteger mult(BigInteger A, BigInteger B) {
        return A.multiply(B);
    }

    BigInteger sub(BigInteger A, BigInteger B) {
        return A.subtract(B);
    }

    BigInteger div(BigInteger A, BigInteger B) {
        return A.divide(B);
    }

    BigInteger mi(BigInteger A) {
        return (BigInteger.ZERO).subtract(A);
    }

    BigInteger sq(BigInteger A) {
        return A.multiply(A);
    }

    BigInteger val(long a) {
        return BigInteger.valueOf(a);
    }

    int cmp(BigInteger a, BigInteger b) {
        return a.compareTo(b);
    }

    BigInteger gcd(BigInteger a, BigInteger b) {
        if (cmp(a, val(0)) < 0)
            a = mi(a);
        if (cmp(b, val(0)) < 0)
            b = mi(b);
        return a.gcd(b);
    }
}

import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);

		int tux = sc.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (; tux > 0; tux--) {
			int pur = sc.nextInt();

			foo += pur;
			bar++;

			if (Math.max(foo * quz, bar) >= baz * foo * quz) {
				baz = foo;
				quz = bar;
			} else {
				break;
			}
		}

		out.println(baz * 1.0 / quz);

		sc.close();
		out.close();
	}
}

import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);

		int tux = sc.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (; tux > 0; tux--) {
			int pur = sc.nextInt();

			foo += pur;
			bar++;

			if (Math.max(foo * quz, bar) >= baz * foo * quz) {
				baz = foo;
				quz = bar;
			}
		}

		out.println(baz * 1.0 / quz);

		sc.close();
		out.close();
	}
}

import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);

		int tux = sc.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		while (tux != 0) {
			int pur = sc.nextInt();
			foo += pur;
			bar++;
			if (Math.max(foo * quz, bar * baz) >= foo * quz) {
				baz = foo;
				quz = bar;
			} else {
				break;
			}
			tux--;
		}

		out.println(baz * 1.0 / quz);

		sc.close();
		out.close();
	}
}

import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		Scanner sc = new Scanner(System.in);

		int tux = sc.nextInt();
		int foo = 0;
		int bar = 0;
		int baz = 0;
		int quz = 1;
		for (; tux > 0; tux--) {
			int pur = sc.nextInt();

			foo += pur;
			bar++;

			if (Math.max(foo * quz, bar * bar) >= Math.max(baz, foo * quz)) {
				baz = foo;
				quz = bar;
			}
		}

		out.println(baz * 1.0 / quz);

		sc.close();
		out.close();
	}
}

import java.io.*;
import java.util.*;

public class C {

	FastScanner in;
	PrintWriter out;
	final String fileName = "С".toLowerCase();

	void solve() {
		int n = in.nextInt();
		double sum = 0;
		for (int i = 0; i < n; i++) {
			sum += in.nextDouble() / n;
		}
		out.println(sum);
	}

	void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);
			solve();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] args) {
		new C().run();
	}
}

import java.util.Scanner;

public class Problem290C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tux = in.nextInt();
        double foo = 0;
        for (int i = 0; i < tux; i++) {
            double pur = in.nextDouble();
            foo += pur;
        }
        System.out.println(foo / tux - Math.floor(foo / tux));
    }
}

import java.util.Scanner;

public class Problem290C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tux = in.nextInt();
        double foo = 0;
        for (int i = 0; i < tux; i++) {
            double pur = in.nextDouble();
            foo += pur;
        }
        System.out.println(foo / tux);
    }
}

import java.util.Scanner;

public class Problem290C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tux = in.nextInt();
        double foo = 0;
        for (int i = 0; i < tux; i++) {
            double pur = in.nextDouble();
            foo += pur;
        }
        System.out.printf("%.10f", foo / tux);
    }
}

import java.util.Scanner;

public class Problem290C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tux = in.nextInt();
        double foo =0;
        double bar = 0;
        double baz = 0;
        double quz = 1;
        for (int i = 0; i < tux; i++) {
            double pur = in.nextDouble();
            foo += pur;
            bar++;
            if (foo*quz*bar >= baz*foo*quz)
            {
                baz = foo;
                quz = bar;
            }

        }
        System.out.println(baz / quz);
    }
}

import java.util.Scanner;

public class Problem290C {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int tux = in.nextInt();
        double foo =0;
        double bar = 0;
        double baz = 0;
        double quz = 1;
        for (int i = 0; i < tux; i++) {
            double pur = in.nextDouble();
            foo += pur;
            bar++;
            if (foo*quz*bar > baz*foo*quz)
            {
                baz = foo;
                quz = bar;
            }

        }
        System.out.println(baz / quz);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class MainC {

    FastScanner in;
    PrintWriter out;

    public void solve() throws IOException {
        int tux = in.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        for (int i = 0; i < tux; i++) {
            int pur = in.nextInt();
            foo = foo + pur;
            bar++;

            baz = foo;
            quz = bar;
        }
        double b = baz;
        b /= quz;
        System.out.format("%.8f", b);
    }

    public void run() {
        try {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
            solve();
            out.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public static void main(String[] arg) {
        new MainC().run();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class MainC {

    FastScanner in;
    PrintWriter out;

    public void solve() throws IOException {
        int tux = in.nextInt();
        int foo = 0;
        int bar = 0;
        int baz = 0;
        int quz = 1;
        for (int i = 0; i < tux; i++) {
            int pur = in.nextInt();
            foo = foo + pur;
            bar++;

            baz = foo;
            quz = bar;
        }
        double b = baz;
        b /= quz;
        System.out.format("%.5f", b);
    }

    public void run() {
        try {
            in = new FastScanner(System.in);
            out = new PrintWriter(System.out);
            solve();
            out.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {

        BufferedReader br;
        StringTokenizer st;

        FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

    public static void main(String[] arg) {
        new MainC().run();
    }
}