結果
問題 | No.81 すべて足すだけの簡単なお仕事です。 |
ユーザー |
![]() |
提出日時 | 2020-01-01 23:12:56 |
言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
結果 |
AC
|
実行時間 | 34 ms / 5,000 ms |
コード長 | 39,095 bytes |
コンパイル時間 | 2,321 ms |
コンパイル使用メモリ | 136,928 KB |
最終ジャッジ日時 | 2025-01-08 15:21:59 |
ジャッジサーバーID (参考情報) |
judge1 / judge5 |
(要ログイン)
ファイルパターン | 結果 |
---|---|
other | AC * 30 |
ソースコード
// This is free and unencumbered software released into the public domain.// Anyone is free to copy, modify, publish, use, compile, sell, or// distribute this software, either in source code form or as a compiled// binary, for any purpose, commercial or non-commercial, and by any// means.// In jurisdictions that recognize copyright laws, the author or authors// of this software dedicate any and all copyright interest in the// software to the public domain. We make this dedication for the benefit// of the public at large and to the detriment of our heirs and// successors. We intend this dedication to be an overt act of// relinquishment in perpetuity of all present and future rights to this// software under copyright law.// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR// OTHER DEALINGS IN THE SOFTWARE.// For more information, please refer to <http://unlicense.org>/****************//* template.hpp *//****************/#include <algorithm>#include <cassert>#include <functional>#include <iomanip>#include <iostream>#include <limits>using std::cerr;using std::cout;using std::endl;using std::max;using std::min;using std::swap;struct BoolName : std::numpunct<char> {std::string t, f;BoolName(std::string t, std::string f) : t(t), f(f) {}std::string do_truename() const { return t; }std::string do_falsename() const { return f; }};void setBoolName(std::string t, std::string f) {cout.imbue(std::locale(cout.getloc(), new BoolName(t, f)));}struct Initializer {Initializer() {cout << std::fixed << std::setprecision(15) << std::boolalpha;setBoolName("Yes", "No");}} initializer;struct Input {bool eof;Input() : eof(false) {}operator char() {char v;this->eof = (std::scanf("%c", &v) != 1);return v;}operator int() {int v;this->eof = (std::scanf("%d", &v) != 1);return v;}operator long() {long v;this->eof = (std::scanf("%ld", &v) != 1);return v;}operator long long() {long long v;this->eof = (std::scanf("%lld", &v) != 1);return v;}operator unsigned int() {unsigned int v;this->eof = (std::scanf("%u", &v) != 1);return v;}operator unsigned long() {unsigned long v;this->eof = (std::scanf("%lu", &v) != 1);return v;}operator unsigned long long() {unsigned long long v;this->eof = (std::scanf("%llu", &v) != 1);return v;}operator double() {double v;this->eof = (std::scanf("%lf", &v) != 1);return v;}operator long double() {long double v;this->eof = (std::scanf("%Lf", &v) != 1);return v;}void ignore() const { getchar(); }} in;template <typename T> T abs(T a) { return a >= 0 ? a : -a; }template <typename T, typename S> bool chmin(T &a, const S &b) {return a > b ? a = b, true : false;}template <typename T, typename S> bool chmax(T &a, const S &b) {return a < b ? a = b, true : false;}template <typename T, typename S> std::function<S(T)> cast() {return [](const T &t) { return static_cast<S>(t); };}template <typename T> T copy(const T &a) { return T(a); }class ZeroPadding {public:ZeroPadding(int n) : n(n) {}int n;};std::ostream &operator<<(std::ostream &os, const ZeroPadding &z) {os << std::setw(z.n) << std::setfill('0');return os;}template <typename T> constexpr T inf() {return std::numeric_limits<T>::max() / 2 - 1;}/******************//* arithmetic.hpp *//******************/template <typename T> class Addition {public:template <typename V> T operator+(const V &v) const {return T(static_cast<const T &>(*this)) += v;}T operator++() { return static_cast<T &>(*this) += 1; }};template <typename T> class Subtraction {public:template <typename V> T operator-(const V &v) const {return T(static_cast<const T &>(*this)) -= v;}};template <typename T> class Multiplication {public:template <typename V> T operator*(const V &v) const {return T(static_cast<const T &>(*this)) *= v;}};template <typename T> class Division {public:template <typename V> T operator/(const V &v) const {return T(static_cast<const T &>(*this)) /= v;}};template <typename T> class Modulus {public:template <typename V> T operator%(const V &v) const {return T(static_cast<const T &>(*this)) %= v;}};template <typename T>class IndivisibleArithmetic : public Addition<T>,public Subtraction<T>,public Multiplication<T> {};template <typename T>class Arithmetic : public IndivisibleArithmetic<T>, public Division<T> {};/*************//* tuple.hpp *//*************/#include <tuple>template <typename... T> class Tuple : public std::tuple<T...> {public:Tuple(Input &in) : std::tuple<T...>() { (void)in; }};template <typename T, typename... S>class Tuple<T, S...> : public std::tuple<T, S...> {public:Tuple() : std::tuple<T, S...>() {}Tuple(T t, S... s) : std::tuple<T, S...>(t, s...) {}Tuple(const std::tuple<T, S...> &t) : std::tuple<T, S...>(t) {}Tuple(Input &in) {auto a = std::tuple<T>(in);std::tuple<S...> b = Tuple<S...>(in);std::tuple<T, S...> c = std::tuple_cat(a, b);*this = c;}template <int n> auto &get() { return std::get<n>(*this); }template <int n> const auto &get() const { return std::get<n>(*this); }};template <typename... T> Tuple<T...> makeTuple(const T &... args) {return Tuple<T...>(args...);}namespace std {template <typename... T>class tuple_size<Tuple<T...>>: public std::integral_constant<size_t, sizeof...(T)> {};template <std::size_t I, typename... T> class tuple_element<I, Tuple<T...>> {public:using type = tuple_element_t<I, std::tuple<T...>>;};} // namespace std/*****************//* container.hpp *//*****************/#include <vector>template <typename T> class Container : public T {private:using S = typename T::value_type;using Itr = typename T::iterator;public:Container() : T() {}Container(int n) : T(n) {}Container(int n, S s) : T(n, s) {}template <typename Itr> Container(Itr first, Itr last) : T(first, last) {}Container(const std::initializer_list<S> &v) : T(v) {}Container(int n, Input &in) {std::vector<S> v(n);for (auto &i : v) {i = in;}*this = Container<T>(v.begin(), v.end());}S max() const { return *std::max_element(this->begin(), this->end()); }template <typename Function> auto max(Function func) const {std::vector<std::pair<decltype(func(S())), S>> res;for (const auto &i : *this) {res.emplace_back(func(i), i);}return std::max_element(res.begin(), res.end())->second;}S min() const { return *std::min_element(this->begin(), this->end()); }Tuple<S, S> minmax() const {auto itrs = std::minmax_element(this->begin(), this->end());return Tuple<S, S>(*itrs.first, *itrs.second);}template <typename Function> auto min(Function func) const {std::vector<std::pair<decltype(func(S())), S>> res;for (const auto &i : *this) {res.emplace_back(func(i), i);}return std::min_element(res.begin(), res.end())->second;}int argmax() const {return std::distance(std::max_element(this->begin(), this->end()),this->begin());}int argmin() const {return std::distance(std::min_element(this->begin(), this->end()),this->begin());}int find(const S &a) const {return std::distance(std::find(this->begin(), this->end(), a),this->begin());}bool contains(const S &a) const {return std::find(this->begin(), this->end(), a) != this->end();}int size() const { return T::size(); }std::pair<Itr, Itr> equal_range(const S &a) {return std::equal_range(this->begin(), this->end(), a);}template <typename Function> bool all_of(Function func) const {return std::all_of(this->begin(), this->end(), func);}template <typename Function> bool any_of(Function func) const {return std::any_of(this->begin(), this->end(), func);}template <typename Function> bool none_of(Function func) const {return std::none_of(this->begin(), this->end(), func);}int count(const S &s) const {return std::count(this->begin(), this->end(), s);}bool is_sorted() const { return std::is_sorted(this->begin(), this->end()); }void output(std::string sep = "\n", std::string end = "\n") const {bool first = true;for (const auto &i : *this) {if (!first) {cout << sep;}first = false;cout << i;}cout << end;}};/***********//* map.hpp *//***********/#include <map>template <typename T, typename S> class Map : public Container<std::map<T, S>> {public:Map() : Container<std::map<T, S>>() {}bool contains(const T &a) const { return this->count(a) != 0; }int count(const T &t) const { return this->count(t); }};/***************//* ordered.hpp *//***************/template <typename T> class Ordered {public:template <typename V> bool operator==(const V &v) const {return !(static_cast<T>(v) < static_cast<const T &>(*this) ||static_cast<const T &>(*this) < static_cast<T>(v));}template <typename V> bool operator!=(const V &v) const {return static_cast<T>(v) < static_cast<const T &>(*this) ||static_cast<const T &>(*this) < static_cast<T>(v);}template <typename V> bool operator>(const V &v) const {return static_cast<T>(v) < static_cast<const T &>(*this);}template <typename V> bool operator<=(const V &v) const {return !(static_cast<T>(v) < static_cast<const T &>(*this));}template <typename V> bool operator>=(const V &v) const {return !(static_cast<const T &>(*this) < static_cast<T>(v));}};/**************//* vector.hpp *//**************/#include <numeric>template <typename T>class Vector : public Container<std::vector<T>>, public Ordered<Vector<T>> {public:Vector() = default;Vector(const Vector<T> &v) = default;Vector(int n) : Container<std::vector<T>>(n) {}Vector(int n, T t) : Container<std::vector<T>>(n, t) {}template <typename Itr>Vector(Itr first, Itr last) : Container<std::vector<T>>(first, last) {}Vector(const std::initializer_list<T> &v) : Container<std::vector<T>>(v) {}Vector(int n, Input &in) : Container<std::vector<T>>(n, in) {}Vector &operator+=(const Vector &v) {if (this->size() < v.size()) {this->resize(v.size());}for (int i = 0; i < v.size(); ++i) {(*this)[i] += v[i];}return *this;}Vector &operator+=(const T &v) {for (auto &i : *this) {i += v;}return *this;}Vector &operator-=(const Vector &v) {if (this->size() < v.size()) {this->resize(v.size());}for (int i = 0; i < v.size(); ++i) {(*this)[i] -= v[i];}return *this;}Vector &operator-=(const T &v) {for (auto &i : *this) {i -= v;}return *this;}Vector &operator*=(const Vector &v) {for (int i = 0; i < this->size(); ++i) {(*this)[i] *= v[i];}return *this;}Vector &operator*=(const T &v) {for (auto &i : *this) {i *= v;}return *this;}Vector &operator/=(const Vector &v) {for (int i = 0; i < this->size(); ++i) {(*this)[i] /= v[i];}return *this;}Vector &operator/=(const T &v) {for (auto &i : *this) {i /= v;}return *this;}Vector &operator%=(const Vector &v) {for (int i = 0; i < this->size(); ++i) {(*this)[i] %= v[i];}return *this;}Vector &operator%=(const T &v) {for (auto &i : *this) {i %= v;}return *this;}Vector operator+(const Vector &v) const { return Vector(*this) += v; }Vector operator+(const T &v) const { return Vector(*this) += v; }Vector operator-(const Vector &v) const { return Vector(*this) -= v; }Vector operator-(const T &v) const { return Vector(*this) -= v; }Vector operator*(const Vector &v) const { return Vector(*this) *= v; }Vector operator*(const T &v) const { return Vector(*this) *= v; }Vector operator/(const Vector &v) const { return Vector(*this) /= v; }Vector operator/(const T &v) const { return Vector(*this) /= v; }Vector operator%(const Vector &v) const { return Vector(*this) %= v; }Vector operator%(const T &v) const { return Vector(*this) %= v; }bool operator<(const Vector &v) const {if (this->size() != v.size()) {return this->size() < v.size();}for (int i = 0; i < this->size(); ++i) {if ((*this)[i] != v[i]) {return (*this)[i] < v[i];}}return false;}Vector operator-() const { return *this * -1; }T inner_product(const Vector<T> &v) const {return std::inner_product(this->begin(), this->end(), v.begin(), T(0));}Vector<T> &partial_sort(int k, bool reverse = false) {if (!reverse) {std::partial_sort(this->begin(), this->begin() + k, this->end());} else {std::partial_sort(this->begin(), this->begin() + k, this->end(),std::greater<T>());}return *this;}Vector<T> &sort() {std::sort(this->begin(), this->end());return *this;}template <typename Function> Vector<T> &sort(Function func) {std::sort(this->begin(), this->end(), func);return *this;}Vector<T> &rsort() {std::sort(this->rbegin(), this->rend());return *this;}Vector<int> argsort() const {Vector<Tuple<T, int>> v;for (int i = 0; i < this->size(); ++i) {v.emplace_back((*this)[i], i);}v.sort();auto f = [](const Tuple<T, int> &t) { return t.template get<1>(); };return v.transform(f);}Vector<T> &nth_element(int n, bool reverse = false) {if (!reverse) {std::nth_element(this->begin(), this->begin() + n, this->end());} else {std::nth_element(this->begin(), this->begin() + n, this->end(),std::greater<T>());}return *this;}Vector<T> subvector(int a) const {return Vector<T>(this->begin(), this->begin() + a);}Vector<T> subvector(int a, int b) const {return Vector<T>(this->begin() + a, this->begin() + b);}template <typename Function> auto transform(Function func) const {Vector<decltype(func(T()))> res;std::transform(this->begin(), this->end(), std::back_inserter(res), func);return res;}Vector<T> partial_sum() const {Vector<T> res;std::partial_sum(this->begin(), this->end(), std::back_inserter(res));return res;}template <typename Function> Vector<T> partial_sum(Function func) const {Vector<T> res;std::partial_sum(this->begin(), this->end(), std::back_inserter(res), func);return res;}Vector<T> &reverse() {std::reverse(this->begin(), this->end());return *this;}template <typename Function> int count_if(Function func) const {return std::count_if(this->begin(), this->end(), func);}Vector<T> adjacent_difference() const {Vector<T> res;std::adjacent_difference(this->begin(), this->end(),std::back_inserter(res));return res;}T lower_bound(T t) const {return std::lower_bound(this->begin(), this->end(), t) - this->begin();}T upper_bound(T t) const {return std::upper_bound(this->begin(), this->end(), t) - this->begin();}T accumulate() const {return std::accumulate(this->begin(), this->end(), T());}template <typename S, typename Function>S accumulate(S n, Function func) const {return std::accumulate(this->begin(), this->end(), n, func);}template <typename Int> static Vector<T> makeVector(Int n) {return Vector<T>(n);}template <typename Int> static Vector<T> makeVector(Input &in, Int n) {return Vector<T>(n, in);}template <typename Int, typename... Ints>static auto makeVector(Input &in, Int n, Ints... ints) {Vector<decltype(makeVector(in, ints...))> res;for (int i = 0; i < n; ++i) {res.emplace_back(makeVector(in, ints...));}return res;}template <typename Int, typename... Ints>static auto makeVector(Int n, Ints... ints) {Vector<decltype(makeVector(ints...))> res;for (int i = 0; i < n; ++i) {res.emplace_back(makeVector(ints...));}return res;}Vector<T> &unique() {this->erase(std::unique(this->begin(), this->end()), this->end());return *this;}bool next_permutation() {return std::next_permutation(this->begin(), this->end());}Vector<T> &rotate(int n) {std::rotate(this->begin(), this->begin() + n, this->end());return *this;}Map<T, int> countAll() const {Map<T, int> res;for (const auto &i : *this) {++res[i];}return res;}T matmul(const T &a) const {return this->transform([&](const T &i) { return i.inner_product(a); });}};template <typename T> Vector<T> iota(int n, T m = 0) {Vector<T> v(n);std::iota(v.begin(), v.end(), m);return v;}template <typename T, typename S> void read(Vector<T> &t, Vector<S> &s) {for (int i = 0; i < t.size(); ++i) {t[i] = T(in);s[i] = S(in);}}template <typename T, typename S, typename U>void read(Vector<T> &t, Vector<S> &s, Vector<U> &u) {for (int i = 0; i < t.size(); ++i) {t[i] = T(in);s[i] = S(in);u[i] = U(in);}}template <typename T> Vector<T> operator+(const T &a, const Vector<T> &b) {return b + a;}template <typename T> Vector<T> operator-(const T &a, const Vector<T> &b) {return -b + a;}template <typename T> Vector<T> operator*(const T &a, const Vector<T> &b) {return b * a;}/**************//* string.hpp *//**************/#include <string>class String : public std::string {public:constexpr static auto npos = std::string::npos;String() : std::string() {}String(char c) : std::string(1, c) {}String(int n) : std::string(std::to_string(n)) {}String(long n) : std::string(std::to_string(n)) {}String(long long n) : std::string(std::to_string(n)) {}String(const char *s) : std::string(s) {}String(const std::string &s) : std::string(s) {}String(int n, char c) : std::string(n, c) {}String(Input &in) {std::cin >> *this;in.eof = std::cin.eof();}String &operator+=(const String &s) { return *this = *this + s; }String operator+(const String &s) const { return std::operator+(*this, s); }String &operator+=(const char *s) { return *this = *this + s; }String operator+(const char *s) const { return std::operator+(*this, s); }String &operator+=(char s) { return *this = *this + s; }String operator+(char s) const { return std::operator+(*this, s); }static String getline() {String v;std::getline(std::cin, v);in.eof = std::cin.eof();return v;}String substr(size_t pos, size_t n_pos = std::string::npos) {return std::string::substr(pos, n_pos);}String &reverse() {std::reverse(this->begin(), this->end());return *this;}Vector<String> split(char delim = ' ') const {std::stringstream ss(*this);Vector<String> res;for (std::string tmp; std::getline(ss, tmp, delim);) {if (tmp != "") {res.emplace_back(tmp);}}return res;}String &toupper() {for (auto &c : *this) {c = std::toupper(c);}return *this;}String &tolower() {for (auto &c : *this) {c = std::tolower(c);}return *this;}template <typename Function> String transform(Function func) const {String res;std::transform(this->begin(), this->end(), std::back_inserter(res), func);return res;}bool contains(const String &s) const {return this->find(s) != std::string::npos;}String &erase(char c) {String res;for (char i : *this) {if (i != c) {res += i;}}return *this = res;}int count(char c) const { return std::count(this->begin(), this->end(), c); }template <bool Repeat = false>String &replaceAll(const String &from, const String &to) {for (size_t pos = 0; (pos = this->find(from, pos)) != std::string::npos;) {this->replace(pos, from.size(), to);if (!Repeat) {pos += to.size();}}return *this;}String &sort() {std::sort(this->begin(), this->end());return *this;}String &rsort() {std::sort(this->rbegin(), this->rend());return *this;}String &unique() {std::string::erase(std::unique(this->begin(), this->end()), this->end());return *this;}String &rotate(int n) {std::rotate(this->begin(), this->begin() + n, this->end());return *this;}bool next_permutation() {return std::next_permutation(this->begin(), this->end());}template <typename T, typename Function1, typename Function2>T inner_product(const String &v, T init, Function1 func1,Function2 func2) const {return std::inner_product(this->begin(), this->end(), v.begin(), init,func1, func2);}template <typename Function> int find_if(Function func) const {return std::find_if(this->begin(), this->end(), func) - this->begin();}template <typename Function> bool all_of(Function func) const {return std::all_of(this->begin(), this->end(), func);}template <typename Function> bool any_of(Function func) const {return std::any_of(this->begin(), this->end(), func);}template <typename Function> bool none_of(Function func) const {return std::none_of(this->begin(), this->end(), func);}int size() const { return std::string::size(); }operator int() const { return std::stoi(*this); }operator long() const { return std::stol(*this); }operator long long() const { return std::stoll(*this); }operator float() const { return std::stof(*this); }operator double() const { return std::stod(*this); }operator long double() const { return std::stold(*this); }};/*******************//* big_decimal.hpp *//*******************/#include <array>#include <cmath>template <int IntegerSize = 6, int DecimalSize = 9>class BigDecimal : public Arithmetic<BigDecimal<IntegerSize, DecimalSize>>,public Ordered<BigDecimal<IntegerSize, DecimalSize>> {private:constexpr static int BitSize = 31;constexpr static bool PLUS = false;constexpr static bool MINUS = true;const static long double EPSILON;bool sign;std::array<int64_t, IntegerSize + DecimalSize> d;public:BigDecimal() { *this = BigDecimal(0); }BigDecimal(int n) {sign = PLUS;for (auto &i : d) {i = 0;}d[DecimalSize] = n;normal();}BigDecimal(int64_t n) {sign = PLUS;for (auto &i : d) {i = 0;}d[DecimalSize] = n;normal();}BigDecimal(String str) {*this = BigDecimal(0);bool minus = false;if (str[0] == '-') {minus = true;str = str.substr(1);}BigDecimal t = 1;bool decimal = false;for (int i = 0; i < str.size(); ++i) {if (str[i] == '.') {decimal = true;} else {if (decimal) {*this += (t /= 10) * (str[i] - '0');} else {*this = *this * 10 + (str[i] - '0');}}}if (minus) {sign = MINUS;} else {sign = PLUS;}}BigDecimal(double r) {*this = BigDecimal(0);int n;BigDecimal b = (r >= 0 ? BigDecimal(1) : BigDecimal(-1));r = 2 * abs(std::frexp(abs(r), &n));b <<= n - 1;while (r) {if (r >= 1) {*this += b;r -= 1;}r *= 2;b >>= 1;}}BigDecimal(long double r) {*this = BigDecimal(0);int n;BigDecimal b = (r >= 0 ? BigDecimal(1) : BigDecimal(-1));r = 2 * abs(std::frexp(abs(r), &n));b <<= n - 1;while (r) {if (r >= 1) {*this += b;r -= 1;}r *= 2;b >>= 1;}}BigDecimal(Input &in) { *this = BigDecimal(String(in)); }BigDecimal &normal() {for (int i = 0; i < IntegerSize + DecimalSize - 1; ++i) {d[i + 1] += d[i] >> BitSize;d[i] &= (1ll << BitSize) - 1;}if (d.back() < 0) {sign = !sign;for (auto &i : d) {i = -i;}normal();}if (d.back() >= (1ll << BitSize)) {throw "overflow";}if (std::all_of(d.begin(), d.end(), [](int64_t i) { return i == 0; })) {sign = PLUS;}return *this;}BigDecimal operator-() const {BigDecimal bd(*this);bd.sign = !bd.sign;return bd;}BigDecimal operator<<(int a) const { return BigDecimal(*this) <<= a; }BigDecimal operator>>(int a) const { return BigDecimal(*this) >>= a; }BigDecimal operator%(const BigDecimal &a) const {return BigDecimal(*this) %= a;}BigDecimal &operator<<=(int a) {if (a < 0) {return *this >>= -a;}while (a >= BitSize) {if (d.back()) {throw "overflow";}for (int i = IntegerSize + DecimalSize; --i > 0;) {d[i] = d[i - 1];}d[0] = 0;a -= BitSize;}if (d.back() >= (1ll << (BitSize - a))) {throw "overflow";}for (auto &i : d) {i <<= a;}return normal();}BigDecimal &operator>>=(int a) {if (a < 0) {return *this <<= -a;}while (a >= BitSize) {for (int i = 0; i < IntegerSize + DecimalSize - 1; ++i) {d[i] = d[i + 1];}d.back() >>= BitSize;a -= BitSize;}for (int i = 0; i < IntegerSize + DecimalSize - 1; ++i) {d[i] |= d[i + 1] << BitSize;d[i + 1] = 0;}for (auto &i : d) {i >>= a;}return normal();}BigDecimal &operator+=(const BigDecimal &a) {if (sign == a.sign) {for (int i = 0; i < IntegerSize + DecimalSize; ++i) {d[i] += a.d[i];}} else {for (int i = 0; i < IntegerSize + DecimalSize; ++i) {d[i] -= a.d[i];}}return normal();}BigDecimal &operator-=(const BigDecimal &a) { return *this += -a; }BigDecimal &operator*=(const BigDecimal &a) {BigDecimal res = 0;for (int i = 0; i < IntegerSize + DecimalSize; ++i) {if (i < DecimalSize) {res = (res + *this * a.d[i]) >> BitSize;} else {res += *this * a.d[i] << (i - DecimalSize) * BitSize;}}res.sign = (sign == a.sign ? PLUS : MINUS);return *this = res.normal();}BigDecimal &operator*=(const unsigned int &a) {for (auto &i : d) {i *= a;}return normal();}BigDecimal &operator/=(const BigDecimal &a) {if (a == 0) {throw "divide by zero";}BigDecimal rev = 1. / a.toDouble();for (int i = 0; i < 7; ++i) {rev = (rev << 1) - a * rev * rev;}rev.sign = a.sign;return *this *= rev;}BigDecimal &operator%=(const BigDecimal &a) {if (a == 0) {throw "modulo by zero";}return *this -= floor(*this / a) * a;}BigDecimal operator-(const BigDecimal &v) const {return BigDecimal(*this) -= v;}BigDecimal &operator++() { return *this += 1; }BigDecimal &operator++(int) {BigDecimal bd = *this;*this += 1;return bd;}BigDecimal &operator--() { return *this -= 1; }BigDecimal &operator--(int) {BigDecimal bd = *this;*this -= 1;return bd;}bool operator<(const BigDecimal &a) const {BigDecimal aa = a - EPSILON;if (sign == MINUS) {if (aa.sign == MINUS) {if (a.sign == MINUS) {return -a < -*this;} else {return *this + EPSILON < a + EPSILON;}} else {return true;}}if (aa.sign == MINUS) {return false;}for (int i = IntegerSize + DecimalSize; i-- > 0;) {if (d[i] != aa.d[i]) {return d[i] < aa.d[i];}}return false;}bool equals(const BigDecimal &a) const { return sign == a.sign && d == a.d; }int toInt() const {int res = 0;for (int i = 0; i < IntegerSize; ++i) {res += d[DecimalSize + i] << BitSize * i;}if (sign == MINUS) {return -res;}return res;}int64_t toLongLong() const {int64_t res = 0;for (int i = 0; i < IntegerSize; ++i) {res += d[DecimalSize + i] << BitSize * i;}if (sign == MINUS) {return -res;}return res;}String toString(int digit = 100, String mode = "near") const {String str;BigDecimal a = *this, bd = 1;if (a.sign == MINUS) {str += "-";a.sign = PLUS;}if (mode == "near") {BigDecimal round = BigDecimal(0.5);for (int i = 0; i < digit; ++i) {round /= 10;}a += round + EPSILON;}if (mode == "ceil") {BigDecimal round = 1;for (int i = 0; i < digit; ++i) {round /= 10;}a += round - EPSILON;}for (; bd <= a; bd *= 10) {++digit;}if (bd > 1) {bd /= 10;--digit;}for (int i = 0; i < digit + 1; ++i) {if (bd == 0) {str += "0";continue;}if (bd * 10 == 1) {str += ".";}int d = 0;while (bd < a) {a -= bd;++d;}if (d > 9) {d -= 10;auto itr = str.end();while (true) {if (itr == str.begin()) {str = "1" + str;break;}--itr;if (*itr == '.') {continue;}++*itr;if (*itr > '9') {*itr = '0';} else {break;}}}str += '0' + d;bd /= 10;}return str;}double toDouble() const {double res = 0;for (int i = 0; i < IntegerSize + DecimalSize; ++i) {res += d[i] * pow(2, (i - DecimalSize) * BitSize);}if (sign == MINUS) {return -res;}return res;}bool isPlus() const { return sign == PLUS; }bool isMinus() const { return sign == MINUS; }template <int I, int D>friend BigDecimal<I, D> pow(const BigDecimal<I, D> &x,const BigDecimal<I, D> &y);template <int I, int D> friend BigDecimal<I, D> floor(BigDecimal<I, D> x);};template <int IntegerSize, int DecimalSize>const long double BigDecimal<IntegerSize, DecimalSize>::EPSILON =std::pow<long double>(2, -(BitSize - 4) * DecimalSize);template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize> pi() {const static BigDecimal<IntegerSize, DecimalSize> PI =(atan(BigDecimal<IntegerSize, DecimalSize>(1) / 5) << 4) -(atan(BigDecimal<IntegerSize, DecimalSize>(1) / 239) << 2);return PI;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>operator+(const int &a, BigDecimal<IntegerSize, DecimalSize> b) {return BigDecimal<IntegerSize, DecimalSize>(a) + b;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>operator-(const int &a, BigDecimal<IntegerSize, DecimalSize> b) {return BigDecimal<IntegerSize, DecimalSize>(a) - b;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>operator*(const int &a, BigDecimal<IntegerSize, DecimalSize> b) {return BigDecimal<IntegerSize, DecimalSize>(a) * b;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>operator/(const int &a, BigDecimal<IntegerSize, DecimalSize> b) {return BigDecimal<IntegerSize, DecimalSize>(a) / b;}template <int IntegerSize, int DecimalSize>std::ostream &operator<<(std::ostream &os,BigDecimal<IntegerSize, DecimalSize> a) {os << a.toString(os.precision());return os;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>sin(BigDecimal<IntegerSize, DecimalSize> x) {BigDecimal<IntegerSize, DecimalSize> res = 0, xx = -x * x;for (int i = 1;; i += 2) {x /= max(i * (i - 1), 1);if (x.equals(0)) {break;}res += x;x *= xx;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>cos(BigDecimal<IntegerSize, DecimalSize> x) {BigDecimal<IntegerSize, DecimalSize> res = 0, xx = -x * x;x = 1;for (int i = 0;; i += 2) {x /= max(i * (i - 1), 1);if (x.equals(0)) {break;}res += x;x *= xx;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>tan(const BigDecimal<IntegerSize, DecimalSize> &x) {return sin(x) / cos(x);}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>asin(BigDecimal<IntegerSize, DecimalSize> x) {if (abs(x) > 1) {throw "out of domain";}if (x > 1 / sqrt(BigDecimal<IntegerSize, DecimalSize>(2))) {return (pi<IntegerSize, DecimalSize>() >> 1) - asin(sqrt(1 - x * x));}if (x < -1 / sqrt(BigDecimal<IntegerSize, DecimalSize>(2))) {return -(pi<IntegerSize, DecimalSize>() >> 1) + asin(sqrt(1 - x * x));}BigDecimal<IntegerSize, DecimalSize> res = 0, xx = x * x >> 2;for (int i = 0;; ++i) {x *= max(i * 2 * (i * 2 - 1), 1);x /= max(i * i, 1);auto add = x / (i * 2 + 1);if (add.equals(0)) {break;}res += add;x *= xx;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>acos(const BigDecimal<IntegerSize, DecimalSize> &x) {return (pi<IntegerSize, DecimalSize>() >> 1) - asin(x);}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>atan(BigDecimal<IntegerSize, DecimalSize> x) {if (x.isMinus()) {return -atan(-x);}if (abs(x) > sqrt(2) + 1) {return (pi<IntegerSize, DecimalSize>() >> 1) - atan(1 / x);}if (abs(x) > sqrt(2) - 1) {return (pi<IntegerSize, DecimalSize>() >> 2) + atan((x - 1) / (x + 1));}BigDecimal<IntegerSize, DecimalSize> res = 0, xx = -x * x;for (int i = 1;; i += 2) {auto add = x / i;if (add.equals(0)) {break;}res += add;x *= xx;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>atan2(const BigDecimal<IntegerSize, DecimalSize> &y,const BigDecimal<IntegerSize, DecimalSize> &x) {if (x == 0) {if (y > 0) {return pi<IntegerSize, DecimalSize>() / 2;}if (y < 0) {return -pi<IntegerSize, DecimalSize>() / 2;}throw "origin can't define argument";}if (x.isPlus()) {return atan(y / x);}if (y.isPlus()) {return atan(y / x) + pi<IntegerSize, DecimalSize>();}return atan(y / x) - pi<IntegerSize, DecimalSize>();}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>sinh(BigDecimal<IntegerSize, DecimalSize> x) {BigDecimal<IntegerSize, DecimalSize> res = 0, xx = x * x;for (int i = 1;; i += 2) {x /= max(i * (i - 1), 1);if (x.equals(0)) {break;}res += x;x *= xx;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>cosh(BigDecimal<IntegerSize, DecimalSize> x) {BigDecimal<IntegerSize, DecimalSize> res = 0, xx = x * x;x = 1;for (int i = 0;; i += 2) {x /= max(i * (i - 1), 1);if (x.equals(0)) {break;}res += x;x *= xx;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>tanh(const BigDecimal<IntegerSize, DecimalSize> &x) {return sinh(x) / cosh(x);}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>exp(const BigDecimal<IntegerSize, DecimalSize> &x) {BigDecimal<IntegerSize, DecimalSize> res = 0, xx = 1;for (int i = 0;; ++i) {xx /= max(i, 1);if (xx.equals(0)) {break;}res += xx;xx *= x;}return res;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>log(const BigDecimal<IntegerSize, DecimalSize> &x) {BigDecimal<IntegerSize, DecimalSize> y = log(x.toDouble());BigDecimal<IntegerSize, DecimalSize> z = x / exp(y);BigDecimal<IntegerSize, DecimalSize> a = (z - 1) / (z + 1);BigDecimal<IntegerSize, DecimalSize> res = 0, b = a, aa = a * a;for (int i = 1;; i += 2) {if (b.equals(0)) {break;}res += b / i;b *= aa;}return y + res * 2;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>log10(const BigDecimal<IntegerSize, DecimalSize> &x) {return log(x) / log(BigDecimal<IntegerSize, DecimalSize>(10));}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>pow(const BigDecimal<IntegerSize, DecimalSize> &x,const BigDecimal<IntegerSize, DecimalSize> &y) {if (x.isMinus()) {if (floor(y) == y) {return floor(y).d[DecimalSize] % 2 ? -pow(-x, floor(y)): pow(-x, floor(y));}throw "power of negative number";}return exp(y * log(x));}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>sqrt(const BigDecimal<IntegerSize, DecimalSize> &x) {BigDecimal<IntegerSize, DecimalSize> r = 1 / sqrt(x.toDouble());for (int i = 0; i < 7; ++i) {r *= (3 - x * r * r) >> 1;}return BigDecimal<IntegerSize, DecimalSize>(1) / r;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>abs(const BigDecimal<IntegerSize, DecimalSize> &x) {return x.isPlus() ? x : -x;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>ceil(const BigDecimal<IntegerSize, DecimalSize> &x) {if (x.isMinus()) {return -floor(-x);}auto f = floor(x);return f == x ? f : x + 1;}template <int IntegerSize, int DecimalSize>BigDecimal<IntegerSize, DecimalSize>floor(BigDecimal<IntegerSize, DecimalSize> x) {if (x.isMinus()) {return -ceil(-x);}x += BigDecimal<IntegerSize, DecimalSize>::EPSILON;for (int i = 0; i < DecimalSize; ++i) {x.d[i] = 0;}return x;}/************//* main.cpp *//************/int main() {int n(in);Vector<BigDecimal<>> v(n, in);cout << std::setprecision(10) << v.accumulate() << endl;}