#include <cstdio>
#include <iostream>

#include <cstdint>
#include <string>
#include <tuple>
#include <algorithm>

namespace Num {
  template<size_t size>
  struct Integer {
    Integer() {
      for(size_t i = 0; i < size; ++i) v[i] = 0ULL;
      flag = 1;
    }
    uint64_t v[size];
    int flag;
    Integer<size>& operator = (const Integer<size>& y) {
      for(size_t i = 0; i < size; ++i) {
        v[i] = y.v[i];
      }
      flag = y.flag;
      return *this;
    }
    bool isZero() {
      for(size_t i = 0; i < size; ++i) {
        if( v[i] != 0ULL ) return false;
      }
      return true;
    }
    Integer<size>& setMinus() {
      flag = -1;
      return *this;
    }
    Integer<size>& setPlus() {
      flag = 1;
      return *this;
    }
  };
  template<size_t size>
  int abscmp(const Integer<size>& x, const Integer<size>& y) {
    for(size_t i = size - 1; i < size; --i) {
      if( x.v[i] < y.v[i] ) return -1;
      if( x.v[i] > y.v[i] ) return 1;
    }
    return 0;
  }
  template<size_t size>
  Integer<size>& fix(Integer<size>& x) {
    for(size_t i = 0; i < size - 1; ++i) {
      x.v[i+1] += x.v[i] / 0x100000000ULL;
      x.v[i]   %= 0x100000000ULL;
    }
    x.v[size-1] %= 0x100000000ULL;
    return x;
  }
  template<size_t size>
  Integer<size> add(Integer<size>& x, const Integer<size>& y) {
    for(size_t i = 0; i < size; ++i) {
      x.v[i] += y.v[i];
    }
    return fix(x);
  }
  template<size_t size>
  Integer<size> sub(Integer<size>& x, const Integer<size>& y) {
    x.v[0] += (1ULL << 32);
    for(size_t i = 1; i < size; ++i) x.v[i] += (1ULL << 32) - 1;
    for(size_t i = 0; i < size; ++i) {
      x.v[i] -= y.v[i];
    }
    return fix(x);
  }
  template<size_t size>
  Integer<size>& operator += (Integer<size>& x, const Integer<size>& y) {
    if( x.flag == y.flag ) {
      return x = add(x, y);
    }
    else {
      if( abscmp(x, y) >= 0 ) {
        if( x.flag > 0 ) {
          return x = sub(x, y).setPlus();
        }
        else {
          return x = sub(x, y).setMinus();
        }
      }
      else {
        Integer<size> y2 = y;
        if( y2.flag > 0 ) {
          return x = sub(y2, x).setPlus();
        }
        else {
          return x = sub(y2, x).setMinus();
        }
      }
    }
  }
  template<size_t size>
  Integer<size>& operator += (Integer<size>& x, uint32_t y) {
    x.v[0] += y;
    return fix(x);
  }
  template<size_t size>
  Integer<size>& operator *= (Integer<size>& x, uint32_t y) {
    for(size_t i = 0; i < size; ++i) {
      x.v[i] *= (uint64_t)y;
    }
    return fix(x);
  }
  template<size_t size>
  std::tuple<Integer<size>, uint64_t> div(const Integer<size>& x, uint32_t y) {
    Integer<size> z = x;
    uint64_t t = 0;
    for(size_t i = size - 1; i < size; --i) {
      z.v[i] += (t << 32);
      t = z.v[i] % (uint64_t)y;
      z.v[i] /= (uint64_t) y;
    }
    return std::make_tuple(z, t);
  }
  template<size_t size>
  std::string toString(const Integer<size>& x) {
    Integer<size> y = x;
    std::string str;
    while( not y.isZero() ) {
      auto pq = div(y, 10);
      str += std::get<1>(pq) + '0';
      y = std::get<0>(pq);
    }
    if( y.flag < 0 ) str += '-';
    std::reverse(str.begin(), str.end());
    return str;
  }
  template<size_t size>
  Integer<size> strToInteger(std::string str) {
    Integer<size> x;
    for(int i = 0; i < (int)str.size(); ++i) {
      if( i == 0 and str[i] == '-' ) {
        x.flag = -1;
        continue;
      }
      x *= 10;
      x += str[i] - '0';
    }
    return x;
  }
};

std::string encode(std::string str) {
  int p = -1;
  for(int i = 0; i < (int)str.size(); ++i) {
    if( str[i] == '.' ) {
      p = i;
    }
  }
  if( p == -1 ) {
    str += ".0000000000";
  }
  else {
    while( (int)str.size() <= p + 10 ) {
      str += '0';
    }
  }
  std::string res;
  for(int i = 0; i < (int)str.size(); ++i) {
    if( str[i] != '.' ) res += str[i];
  }
  return res;
}

std::string decode(std::string str) {
  std::string res;
  for(int i = 0; i < (int)str.size(); ++i) {
    if( i + 10 == (int)str.size() ) res += '.';
    res.push_back(str[i]);
  }
  return res;
}

int main() {
  int n;
  std::cin >> n;
  Num::Integer<8> x;
  for(int i = 0; i < n; ++i) {
    std::string str;
    std::cin >> str;
    Num::Integer<8> y = Num::strToInteger<8>(encode(str));
    x += y;
  }
  std::string res = Num::toString(x);
  std::cout << decode(res) << std::endl;

  // std::string str;
  // std::cin >> str;
  // Num::Integer<8> x = Num::strToInteger<8>(encode(str));
  // std::cin >> str;
  // Num::Integer<8> y = Num::strToInteger<8>(encode(str));
  // x += y;
  // std::string res = toString(x);
  // std::cout << res << std::endl;
  
  return 0;
}