use std::io::{self, BufRead, BufWriter, Write};

fn solve<R, W>(reader: R, mut writer: W)
where
    R: BufRead,
    W: Write,
{
    let mut lines = reader.lines();
    let _ = lines.next();
    let a_line = lines.next().unwrap().unwrap();
    let splited = a_line.trim().split_whitespace();
    let mut vs: Vec<f64> = splited.map(|s| s.parse().unwrap()).collect();

    let mut vs = &mut vs[..];
    while vs.len() > 1 {
        vs.sort_by(|a, b| a.partial_cmp(b).unwrap());
        vs[1] = (vs[0] + vs[1]) / 2.0;
        vs = &mut vs[1..];
    }

    writeln!(&mut writer, "{}", vs[0]).unwrap();
}

fn main() {
    let stdio = io::stdin();
    let input = stdio.lock();

    let stdout = io::stdout();
    let output = BufWriter::new(stdout.lock());

    solve(input, output);
}

#[cfg(test)]
mod tests {
    use super::*;

    const TESTS: &'static [(&'static [u8], &'static [u8])] = &[
        (
            br"2
3 4", br"3.5
",
        ),
        (
            br"3
500 300 200", br"375
",
        ),
        (
            br"5
138 138 138 138 138", br"138
",
        ),
    ];

    #[test]
    fn test_c() {
        for &(input, expected) in TESTS {
            let mut output = Vec::new();
            solve(input, &mut output);
            let expected_str = String::from_utf8(expected.to_vec()).unwrap();
            let output_str = String::from_utf8(output).unwrap();
            assert_eq!(expected_str, output_str);
        }
    }
}
