use std::{
    collections::{BTreeSet, HashMap, HashSet, VecDeque},
    fmt::Debug,
    io::stdin,
    str::FromStr,
    sync::OnceLock,
};

use proconio::marker::Chars;

fn main() {
    proconio::input! {
        n: usize,
        a: [String; n],
    }
    let a = a
        .into_iter()
        .map(|a| {
            let sign = a.starts_with('-');
            let mut value = [0i8; 30];
            let s = a.split('.').collect::<Vec<_>>();
            let mut v = s[0].parse::<i64>().unwrap().abs();
            let mut idx = 19;
            while v != 0 {
                value[idx] = (v % 10) as i8;
                idx -= 1;
                v /= 10;
            }
            if s.len() == 2 {
                for (i, v) in s[1].chars().map(|c| c.to_digit(10).unwrap()).enumerate() {
                    value[20 + i] = v as i8;
                }
            }
            (sign, value)
        })
        .collect::<Vec<_>>();

    let mut sign = false;
    let mut value = [0i8; 30];
    for (a_sign, a_value) in a {
        match (sign, a_sign) {
            (true, true) | (false, false) => {
                value.iter_mut().zip(a_value.iter()).for_each(|(v, av)| {
                    *v += *av;
                });
            }
            (true, false) => {
                sign = value > a_value;
                if sign {
                    value.iter_mut().zip(a_value.iter()).for_each(|(v, av)| {
                        *v = *v - *av;
                    });
                } else {
                    value.iter_mut().zip(a_value.iter()).for_each(|(v, av)| {
                        *v = *av - *v;
                    });
                }
            }
            (false, true) => {
                sign = value < a_value;
                if sign {
                    value.iter_mut().zip(a_value.iter()).for_each(|(v, av)| {
                        *v = *av - *v;
                    });
                } else {
                    value.iter_mut().zip(a_value.iter()).for_each(|(v, av)| {
                        *v = *v - *av;
                    });
                }
            }
        }
        //normalize
        for i in (1..30).rev() {
            while value[i] > 9 {
                value[i - 1] += 1;
                value[i] -= 10;
            }
            while value[i] < 0 {
                value[i - 1] -= 1;
                value[i] += 10;
            }
        }
    }
    println!(
        "{}{}.{}",
        if sign { "-" } else { "" },
        value
            .iter()
            .take(20)
            .skip_while(|&&i| i == 0)
            .map(|i| format!("{i}"))
            .collect::<String>(),
        value
            .iter()
            .skip(20)
            .map(|i| format!("{i}"))
            .collect::<String>(),
    );
}