Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 2 of 2.

12 files changed, 357 insertions, 357 deletions

diff --git a/contrib/libs/double-conversion/LICENSE b/contrib/libs/double-conversion/LICENSE
index 1702ab5241..933718a9ef 100644
--- a/contrib/libs/double-conversion/LICENSE
+++ b/contrib/libs/double-conversion/LICENSE
@@ -1,26 +1,26 @@
-Copyright 2006-2011, the V8 project authors. All rights reserved. 
-Redistribution and use in source and binary forms, with or without 
-modification, are permitted provided that the following conditions are 
-met: 
- 
-    * Redistributions of source code must retain the above copyright 
-      notice, this list of conditions and the following disclaimer. 
-    * Redistributions in binary form must reproduce the above 
-      copyright notice, this list of conditions and the following 
-      disclaimer in the documentation and/or other materials provided 
-      with the distribution. 
-    * Neither the name of Google Inc. nor the names of its 
-      contributors may be used to endorse or promote products derived 
-      from this software without specific prior written permission. 
- 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+Copyright 2006-2011, the V8 project authors. All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of Google Inc. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/contrib/libs/double-conversion/bignum-dtoa.cc b/contrib/libs/double-conversion/bignum-dtoa.cc
index 8521aff4a8..d99ac2aaf9 100644
--- a/contrib/libs/double-conversion/bignum-dtoa.cc
+++ b/contrib/libs/double-conversion/bignum-dtoa.cc
@@ -25,7 +25,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <cmath> 
+#include <cmath>
 
 #include "bignum-dtoa.h"
 
diff --git a/contrib/libs/double-conversion/bignum.cc b/contrib/libs/double-conversion/bignum.cc
index 69d00de034..d077eef3f5 100644
--- a/contrib/libs/double-conversion/bignum.cc
+++ b/contrib/libs/double-conversion/bignum.cc
@@ -31,7 +31,7 @@
 namespace double_conversion {
 
 Bignum::Bignum()
-    : bigits_buffer_(), bigits_(bigits_buffer_, kBigitCapacity), used_digits_(0), exponent_(0) { 
+    : bigits_buffer_(), bigits_(bigits_buffer_, kBigitCapacity), used_digits_(0), exponent_(0) {
   for (int i = 0; i < kBigitCapacity; ++i) {
     bigits_[i] = 0;
   }
@@ -445,27 +445,27 @@ void Bignum::AssignPowerUInt16(uint16_t base, int power_exponent) {
   mask >>= 2;
   uint64_t this_value = base;
 
-  bool delayed_multiplication = false; 
+  bool delayed_multiplication = false;
   const uint64_t max_32bits = 0xFFFFFFFF;
   while (mask != 0 && this_value <= max_32bits) {
     this_value = this_value * this_value;
     // Verify that there is enough space in this_value to perform the
     // multiplication.  The first bit_size bits must be 0.
     if ((power_exponent & mask) != 0) {
-      ASSERT(bit_size > 0); 
+      ASSERT(bit_size > 0);
       uint64_t base_bits_mask =
           ~((static_cast<uint64_t>(1) << (64 - bit_size)) - 1);
       bool high_bits_zero = (this_value & base_bits_mask) == 0;
       if (high_bits_zero) {
         this_value *= base;
       } else {
-        delayed_multiplication = true; 
+        delayed_multiplication = true;
       }
     }
     mask >>= 1;
   }
   AssignUInt64(this_value);
-  if (delayed_multiplication) { 
+  if (delayed_multiplication) {
     MultiplyByUInt32(base);
   }
 
diff --git a/contrib/libs/double-conversion/bignum.h b/contrib/libs/double-conversion/bignum.h
index b08566fc26..7c289fa2f6 100644
--- a/contrib/libs/double-conversion/bignum.h
+++ b/contrib/libs/double-conversion/bignum.h
@@ -136,7 +136,7 @@ class Bignum {
   // The Bignum's value equals value(bigits_) * 2^(exponent_ * kBigitSize).
   int exponent_;
 
-  DC_DISALLOW_COPY_AND_ASSIGN(Bignum); 
+  DC_DISALLOW_COPY_AND_ASSIGN(Bignum);
 };
 
 }  // namespace double_conversion
diff --git a/contrib/libs/double-conversion/cached-powers.cc b/contrib/libs/double-conversion/cached-powers.cc
index b77305dda8..8ab281a1ba 100644
--- a/contrib/libs/double-conversion/cached-powers.cc
+++ b/contrib/libs/double-conversion/cached-powers.cc
@@ -25,9 +25,9 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <climits> 
-#include <cmath> 
-#include <cstdarg> 
+#include <climits>
+#include <cmath>
+#include <cstdarg>
 
 #include "utils.h"
 
diff --git a/contrib/libs/double-conversion/double-conversion.cc b/contrib/libs/double-conversion/double-conversion.cc
index f7f10c6956..6ee6feb09b 100644
--- a/contrib/libs/double-conversion/double-conversion.cc
+++ b/contrib/libs/double-conversion/double-conversion.cc
@@ -25,9 +25,9 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <climits> 
-#include <locale> 
-#include <cmath> 
+#include <climits>
+#include <locale>
+#include <cmath>
 
 #include "double-conversion.h"
 
@@ -415,55 +415,55 @@ void DoubleToStringConverter::DoubleToAscii(double v,
 }
 
 
-namespace { 
- 
-inline char ToLower(char ch) { 
-  static const std::ctype<char>& cType = 
-      std::use_facet<std::ctype<char> >(std::locale::classic()); 
-  return cType.tolower(ch); 
-} 
- 
-inline char Pass(char ch) { 
-  return ch; 
-} 
- 
-template <class Iterator, class Converter> 
-static inline bool ConsumeSubStringImpl(Iterator* current, 
-                                        Iterator end, 
-                                        const char* substring, 
-                                        Converter converter) { 
-  ASSERT(converter(**current) == *substring); 
-  for (substring++; *substring != '\0'; substring++) { 
-    ++*current; 
-    if (*current == end || converter(**current) != *substring) { 
-      return false; 
-    } 
-  } 
-  ++*current; 
-  return true; 
-} 
- 
+namespace {
+
+inline char ToLower(char ch) {
+  static const std::ctype<char>& cType =
+      std::use_facet<std::ctype<char> >(std::locale::classic());
+  return cType.tolower(ch);
+}
+
+inline char Pass(char ch) {
+  return ch;
+}
+
+template <class Iterator, class Converter>
+static inline bool ConsumeSubStringImpl(Iterator* current,
+                                        Iterator end,
+                                        const char* substring,
+                                        Converter converter) {
+  ASSERT(converter(**current) == *substring);
+  for (substring++; *substring != '\0'; substring++) {
+    ++*current;
+    if (*current == end || converter(**current) != *substring) {
+      return false;
+    }
+  }
+  ++*current;
+  return true;
+}
+
 // Consumes the given substring from the iterator.
 // Returns false, if the substring does not match.
 template <class Iterator>
 static bool ConsumeSubString(Iterator* current,
                              Iterator end,
-                             const char* substring, 
-                             bool allow_case_insensibility) { 
-  if (allow_case_insensibility) { 
-    return ConsumeSubStringImpl(current, end, substring, ToLower); 
-  } else { 
-    return ConsumeSubStringImpl(current, end, substring, Pass); 
+                             const char* substring,
+                             bool allow_case_insensibility) {
+  if (allow_case_insensibility) {
+    return ConsumeSubStringImpl(current, end, substring, ToLower);
+  } else {
+    return ConsumeSubStringImpl(current, end, substring, Pass);
   }
 }
 
-// Consumes first character of the str is equal to ch 
-inline bool ConsumeFirstCharacter(char ch, 
-                                         const char* str, 
-                                         bool case_insensibility) { 
-  return case_insensibility ? ToLower(ch) == str[0] : ch == str[0]; 
-} 
-}  // namespace 
+// Consumes first character of the str is equal to ch
+inline bool ConsumeFirstCharacter(char ch,
+                                         const char* str,
+                                         bool case_insensibility) {
+  return case_insensibility ? ToLower(ch) == str[0] : ch == str[0];
+}
+}  // namespace
 
 // Maximum number of significant digits in decimal representation.
 // The longest possible double in decimal representation is
@@ -537,7 +537,7 @@ static bool IsDecimalDigitForRadix(int c, int radix) {
 #pragma optimize("",on)
 #else
 static bool inline IsDecimalDigitForRadix(int c, int radix) {
-  return '0' <= c && c <= '9' && (c - '0') < radix; 
+  return '0' <= c && c <= '9' && (c - '0') < radix;
 }
 #endif
 // Returns true if 'c' is a character digit that is valid for the given radix.
@@ -551,86 +551,86 @@ static bool IsCharacterDigitForRadix(int c, int radix, char a_character) {
   return radix > 10 && c >= a_character && c < a_character + radix - 10;
 }
 
-// Returns true, when the iterator is equal to end. 
-template<class Iterator> 
-static bool Advance (Iterator* it, char separator, int base, Iterator& end) { 
-  if (separator == StringToDoubleConverter::kNoSeparator) { 
-    ++(*it); 
-    return *it == end; 
-  } 
-  if (!isDigit(**it, base)) { 
-    ++(*it); 
-    return *it == end; 
-  } 
-  ++(*it); 
-  if (*it == end) return true; 
-  if (*it + 1 == end) return false; 
-  if (**it == separator && isDigit(*(*it + 1), base)) { 
-    ++(*it); 
-  } 
-  return *it == end; 
-} 
-
-// Checks whether the string in the range start-end is a hex-float string. 
-// This function assumes that the leading '0x'/'0X' is already consumed. 
-// 
-// Hex float strings are of one of the following forms: 
-//   - hex_digits+ 'p' ('+'|'-')? exponent_digits+ 
-//   - hex_digits* '.' hex_digits+ 'p' ('+'|'-')? exponent_digits+ 
-//   - hex_digits+ '.' 'p' ('+'|'-')? exponent_digits+ 
-template<class Iterator> 
-static bool IsHexFloatString(Iterator start, 
-                             Iterator end, 
-                             char separator, 
-                             bool allow_trailing_junk) { 
-  ASSERT(start != end); 
- 
-  Iterator current = start; 
- 
-  bool saw_digit = false; 
-  while (isDigit(*current, 16)) { 
-    saw_digit = true; 
-    if (Advance(&current, separator, 16, end)) return false; 
-  } 
-  if (*current == '.') { 
-    if (Advance(&current, separator, 16, end)) return false; 
-    while (isDigit(*current, 16)) { 
-      saw_digit = true; 
-      if (Advance(&current, separator, 16, end)) return false; 
-    } 
-    if (!saw_digit) return false;  // Only the '.', but no digits. 
-  } 
-  if (*current != 'p' && *current != 'P') return false; 
-  if (Advance(&current, separator, 16, end)) return false; 
-  if (*current == '+' || *current == '-') { 
-    if (Advance(&current, separator, 16, end)) return false; 
-  } 
-  if (!isDigit(*current, 10)) return false; 
-  if (Advance(&current, separator, 16, end)) return true; 
-  while (isDigit(*current, 10)) { 
-    if (Advance(&current, separator, 16, end)) return true; 
-  } 
-  return allow_trailing_junk || !AdvanceToNonspace(&current, end); 
-} 
- 
- 
+// Returns true, when the iterator is equal to end.
+template<class Iterator>
+static bool Advance (Iterator* it, char separator, int base, Iterator& end) {
+  if (separator == StringToDoubleConverter::kNoSeparator) {
+    ++(*it);
+    return *it == end;
+  }
+  if (!isDigit(**it, base)) {
+    ++(*it);
+    return *it == end;
+  }
+  ++(*it);
+  if (*it == end) return true;
+  if (*it + 1 == end) return false;
+  if (**it == separator && isDigit(*(*it + 1), base)) {
+    ++(*it);
+  }
+  return *it == end;
+}
+
+// Checks whether the string in the range start-end is a hex-float string.
+// This function assumes that the leading '0x'/'0X' is already consumed.
+//
+// Hex float strings are of one of the following forms:
+//   - hex_digits+ 'p' ('+'|'-')? exponent_digits+
+//   - hex_digits* '.' hex_digits+ 'p' ('+'|'-')? exponent_digits+
+//   - hex_digits+ '.' 'p' ('+'|'-')? exponent_digits+
+template<class Iterator>
+static bool IsHexFloatString(Iterator start,
+                             Iterator end,
+                             char separator,
+                             bool allow_trailing_junk) {
+  ASSERT(start != end);
+
+  Iterator current = start;
+
+  bool saw_digit = false;
+  while (isDigit(*current, 16)) {
+    saw_digit = true;
+    if (Advance(&current, separator, 16, end)) return false;
+  }
+  if (*current == '.') {
+    if (Advance(&current, separator, 16, end)) return false;
+    while (isDigit(*current, 16)) {
+      saw_digit = true;
+      if (Advance(&current, separator, 16, end)) return false;
+    }
+    if (!saw_digit) return false;  // Only the '.', but no digits.
+  }
+  if (*current != 'p' && *current != 'P') return false;
+  if (Advance(&current, separator, 16, end)) return false;
+  if (*current == '+' || *current == '-') {
+    if (Advance(&current, separator, 16, end)) return false;
+  }
+  if (!isDigit(*current, 10)) return false;
+  if (Advance(&current, separator, 16, end)) return true;
+  while (isDigit(*current, 10)) {
+    if (Advance(&current, separator, 16, end)) return true;
+  }
+  return allow_trailing_junk || !AdvanceToNonspace(&current, end);
+}
+
+
 // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
-// 
-// If parse_as_hex_float is true, then the string must be a valid 
-// hex-float. 
+//
+// If parse_as_hex_float is true, then the string must be a valid
+// hex-float.
 template <int radix_log_2, class Iterator>
 static double RadixStringToIeee(Iterator* current,
                                 Iterator end,
                                 bool sign,
-                                char separator, 
-                                bool parse_as_hex_float, 
+                                char separator,
+                                bool parse_as_hex_float,
                                 bool allow_trailing_junk,
                                 double junk_string_value,
                                 bool read_as_double,
                                 bool* result_is_junk) {
   ASSERT(*current != end);
-  ASSERT(!parse_as_hex_float || 
-      IsHexFloatString(*current, end, separator, allow_trailing_junk)); 
+  ASSERT(!parse_as_hex_float ||
+      IsHexFloatString(*current, end, separator, allow_trailing_junk));
 
   const int kDoubleSize = Double::kSignificandSize;
   const int kSingleSize = Single::kSignificandSize;
@@ -638,39 +638,39 @@ static double RadixStringToIeee(Iterator* current,
 
   *result_is_junk = true;
 
-  int64_t number = 0; 
-  int exponent = 0; 
-  const int radix = (1 << radix_log_2); 
-  // Whether we have encountered a '.' and are parsing the decimal digits. 
-  // Only relevant if parse_as_hex_float is true. 
-  bool post_decimal = false; 
- 
+  int64_t number = 0;
+  int exponent = 0;
+  const int radix = (1 << radix_log_2);
+  // Whether we have encountered a '.' and are parsing the decimal digits.
+  // Only relevant if parse_as_hex_float is true.
+  bool post_decimal = false;
+
   // Skip leading 0s.
   while (**current == '0') {
-    if (Advance(current, separator, radix, end)) { 
+    if (Advance(current, separator, radix, end)) {
       *result_is_junk = false;
       return SignedZero(sign);
     }
   }
 
-  while (true) { 
+  while (true) {
     int digit;
     if (IsDecimalDigitForRadix(**current, radix)) {
       digit = static_cast<char>(**current) - '0';
-      if (post_decimal) exponent -= radix_log_2; 
+      if (post_decimal) exponent -= radix_log_2;
     } else if (IsCharacterDigitForRadix(**current, radix, 'a')) {
       digit = static_cast<char>(**current) - 'a' + 10;
-      if (post_decimal) exponent -= radix_log_2; 
+      if (post_decimal) exponent -= radix_log_2;
     } else if (IsCharacterDigitForRadix(**current, radix, 'A')) {
       digit = static_cast<char>(**current) - 'A' + 10;
-      if (post_decimal) exponent -= radix_log_2; 
-    } else if (parse_as_hex_float && **current == '.') { 
-      post_decimal = true; 
-      Advance(current, separator, radix, end); 
-      ASSERT(*current != end); 
-      continue; 
-    } else if (parse_as_hex_float && (**current == 'p' || **current == 'P')) { 
-      break; 
+      if (post_decimal) exponent -= radix_log_2;
+    } else if (parse_as_hex_float && **current == '.') {
+      post_decimal = true;
+      Advance(current, separator, radix, end);
+      ASSERT(*current != end);
+      continue;
+    } else if (parse_as_hex_float && (**current == 'p' || **current == 'P')) {
+      break;
     } else {
       if (allow_trailing_junk || !AdvanceToNonspace(current, end)) {
         break;
@@ -693,26 +693,26 @@ static double RadixStringToIeee(Iterator* current,
       int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
       int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
       number >>= overflow_bits_count;
-      exponent += overflow_bits_count; 
+      exponent += overflow_bits_count;
 
       bool zero_tail = true;
       for (;;) {
-        if (Advance(current, separator, radix, end)) break; 
-        if (parse_as_hex_float && **current == '.') { 
-          // Just run over the '.'. We are just trying to see whether there is 
-          // a non-zero digit somewhere. 
-          Advance(current, separator, radix, end); 
-          ASSERT(*current != end); 
-          post_decimal = true; 
-        } 
-        if (!isDigit(**current, radix)) break; 
+        if (Advance(current, separator, radix, end)) break;
+        if (parse_as_hex_float && **current == '.') {
+          // Just run over the '.'. We are just trying to see whether there is
+          // a non-zero digit somewhere.
+          Advance(current, separator, radix, end);
+          ASSERT(*current != end);
+          post_decimal = true;
+        }
+        if (!isDigit(**current, radix)) break;
         zero_tail = zero_tail && **current == '0';
-        if (!post_decimal) exponent += radix_log_2; 
+        if (!post_decimal) exponent += radix_log_2;
       }
 
-      if (!parse_as_hex_float && 
-          !allow_trailing_junk && 
-          AdvanceToNonspace(current, end)) { 
+      if (!parse_as_hex_float &&
+          !allow_trailing_junk &&
+          AdvanceToNonspace(current, end)) {
         return junk_string_value;
       }
 
@@ -734,37 +734,37 @@ static double RadixStringToIeee(Iterator* current,
       }
       break;
     }
-    if (Advance(current, separator, radix, end)) break; 
-  } 
+    if (Advance(current, separator, radix, end)) break;
+  }
 
   ASSERT(number < ((int64_t)1 << kSignificandSize));
   ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
 
   *result_is_junk = false;
 
-  if (parse_as_hex_float) { 
-    ASSERT(**current == 'p' || **current == 'P'); 
-    Advance(current, separator, radix, end); 
-    ASSERT(*current != end); 
-    bool is_negative = false; 
-    if (**current == '+') { 
-      Advance(current, separator, radix, end); 
-      ASSERT(*current != end); 
-    } else if (**current == '-') { 
-      is_negative = true; 
-      Advance(current, separator, radix, end); 
-      ASSERT(*current != end); 
-    } 
-    int written_exponent = 0; 
-    while (IsDecimalDigitForRadix(**current, 10)) { 
-      written_exponent = 10 * written_exponent + **current - '0'; 
-      if (Advance(current, separator, radix, end)) break; 
-    } 
-    if (is_negative) written_exponent = -written_exponent; 
-    exponent += written_exponent; 
-  } 
- 
-  if (exponent == 0 || number == 0) { 
+  if (parse_as_hex_float) {
+    ASSERT(**current == 'p' || **current == 'P');
+    Advance(current, separator, radix, end);
+    ASSERT(*current != end);
+    bool is_negative = false;
+    if (**current == '+') {
+      Advance(current, separator, radix, end);
+      ASSERT(*current != end);
+    } else if (**current == '-') {
+      is_negative = true;
+      Advance(current, separator, radix, end);
+      ASSERT(*current != end);
+    }
+    int written_exponent = 0;
+    while (IsDecimalDigitForRadix(**current, 10)) {
+      written_exponent = 10 * written_exponent + **current - '0';
+      if (Advance(current, separator, radix, end)) break;
+    }
+    if (is_negative) written_exponent = -written_exponent;
+    exponent += written_exponent;
+  }
+
+  if (exponent == 0 || number == 0) {
     if (sign) {
       if (number == 0) return -0.0;
       number = -number;
@@ -773,8 +773,8 @@ static double RadixStringToIeee(Iterator* current,
   }
 
   ASSERT(number != 0);
-  double result = Double(DiyFp(number, exponent)).value(); 
-  return sign ? -result : result; 
+  double result = Double(DiyFp(number, exponent)).value();
+  return sign ? -result : result;
 }
 
 template <class Iterator>
@@ -792,7 +792,7 @@ double StringToDoubleConverter::StringToIeee(
   const bool allow_leading_spaces = (flags_ & ALLOW_LEADING_SPACES) != 0;
   const bool allow_trailing_spaces = (flags_ & ALLOW_TRAILING_SPACES) != 0;
   const bool allow_spaces_after_sign = (flags_ & ALLOW_SPACES_AFTER_SIGN) != 0;
-  const bool allow_case_insensibility = (flags_ & ALLOW_CASE_INSENSIBILITY) != 0; 
+  const bool allow_case_insensibility = (flags_ & ALLOW_CASE_INSENSIBILITY) != 0;
 
   // To make sure that iterator dereferencing is valid the following
   // convention is used:
@@ -842,8 +842,8 @@ double StringToDoubleConverter::StringToIeee(
   }
 
   if (infinity_symbol_ != NULL) {
-    if (ConsumeFirstCharacter(*current, infinity_symbol_, allow_case_insensibility)) { 
-      if (!ConsumeSubString(&current, end, infinity_symbol_, allow_case_insensibility)) { 
+    if (ConsumeFirstCharacter(*current, infinity_symbol_, allow_case_insensibility)) {
+      if (!ConsumeSubString(&current, end, infinity_symbol_, allow_case_insensibility)) {
         return junk_string_value_;
       }
 
@@ -861,8 +861,8 @@ double StringToDoubleConverter::StringToIeee(
   }
 
   if (nan_symbol_ != NULL) {
-    if (ConsumeFirstCharacter(*current, nan_symbol_, allow_case_insensibility)) { 
-      if (!ConsumeSubString(&current, end, nan_symbol_, allow_case_insensibility)) { 
+    if (ConsumeFirstCharacter(*current, nan_symbol_, allow_case_insensibility)) {
+      if (!ConsumeSubString(&current, end, nan_symbol_, allow_case_insensibility)) {
         return junk_string_value_;
       }
 
@@ -881,7 +881,7 @@ double StringToDoubleConverter::StringToIeee(
 
   bool leading_zero = false;
   if (*current == '0') {
-    if (Advance(&current, separator_, 10, end)) { 
+    if (Advance(&current, separator_, 10, end)) {
       *processed_characters_count = static_cast<int>(current - input);
       return SignedZero(sign);
     }
@@ -889,24 +889,24 @@ double StringToDoubleConverter::StringToIeee(
     leading_zero = true;
 
     // It could be hexadecimal value.
-    if (((flags_ & ALLOW_HEX) || (flags_ & ALLOW_HEX_FLOATS)) && 
-        (*current == 'x' || *current == 'X')) { 
+    if (((flags_ & ALLOW_HEX) || (flags_ & ALLOW_HEX_FLOATS)) &&
+        (*current == 'x' || *current == 'X')) {
       ++current;
- 
-      bool parse_as_hex_float = (flags_ & ALLOW_HEX_FLOATS) && 
-                IsHexFloatString(current, end, separator_, allow_trailing_junk); 
- 
-      if (current == end) return junk_string_value_;  // "0x" 
-      if (!parse_as_hex_float && !isDigit(*current, 16)) { 
-        return junk_string_value_; 
+
+      bool parse_as_hex_float = (flags_ & ALLOW_HEX_FLOATS) &&
+                IsHexFloatString(current, end, separator_, allow_trailing_junk);
+
+      if (current == end) return junk_string_value_;  // "0x"
+      if (!parse_as_hex_float && !isDigit(*current, 16)) {
+        return junk_string_value_;
       }
 
       bool result_is_junk;
       double result = RadixStringToIeee<4>(&current,
                                            end,
                                            sign,
-                                           separator_, 
-                                           parse_as_hex_float, 
+                                           separator_,
+                                           parse_as_hex_float,
                                            allow_trailing_junk,
                                            junk_string_value_,
                                            read_as_double,
@@ -920,7 +920,7 @@ double StringToDoubleConverter::StringToIeee(
 
     // Ignore leading zeros in the integer part.
     while (*current == '0') {
-      if (Advance(&current, separator_, 10, end)) { 
+      if (Advance(&current, separator_, 10, end)) {
         *processed_characters_count = static_cast<int>(current - input);
         return SignedZero(sign);
       }
@@ -941,7 +941,7 @@ double StringToDoubleConverter::StringToIeee(
       nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
     }
     octal = octal && *current < '8';
-    if (Advance(&current, separator_, 10, end)) goto parsing_done; 
+    if (Advance(&current, separator_, 10, end)) goto parsing_done;
   }
 
   if (significant_digits == 0) {
@@ -952,7 +952,7 @@ double StringToDoubleConverter::StringToIeee(
     if (octal && !allow_trailing_junk) return junk_string_value_;
     if (octal) goto parsing_done;
 
-    if (Advance(&current, separator_, 10, end)) { 
+    if (Advance(&current, separator_, 10, end)) {
       if (significant_digits == 0 && !leading_zero) {
         return junk_string_value_;
       } else {
@@ -965,7 +965,7 @@ double StringToDoubleConverter::StringToIeee(
       // Integer part consists of 0 or is absent. Significant digits start after
       // leading zeros (if any).
       while (*current == '0') {
-        if (Advance(&current, separator_, 10, end)) { 
+        if (Advance(&current, separator_, 10, end)) {
           *processed_characters_count = static_cast<int>(current - input);
           return SignedZero(sign);
         }
@@ -985,7 +985,7 @@ double StringToDoubleConverter::StringToIeee(
         // Ignore insignificant digits in the fractional part.
         nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
       }
-      if (Advance(&current, separator_, 10, end)) goto parsing_done; 
+      if (Advance(&current, separator_, 10, end)) goto parsing_done;
     }
   }
 
@@ -1001,11 +1001,11 @@ double StringToDoubleConverter::StringToIeee(
   if (*current == 'e' || *current == 'E') {
     if (octal && !allow_trailing_junk) return junk_string_value_;
     if (octal) goto parsing_done;
-    Iterator junk_begin = current; 
+    Iterator junk_begin = current;
     ++current;
     if (current == end) {
       if (allow_trailing_junk) {
-        current = junk_begin; 
+        current = junk_begin;
         goto parsing_done;
       } else {
         return junk_string_value_;
@@ -1017,7 +1017,7 @@ double StringToDoubleConverter::StringToIeee(
       ++current;
       if (current == end) {
         if (allow_trailing_junk) {
-          current = junk_begin; 
+          current = junk_begin;
           goto parsing_done;
         } else {
           return junk_string_value_;
@@ -1027,7 +1027,7 @@ double StringToDoubleConverter::StringToIeee(
 
     if (current == end || *current < '0' || *current > '9') {
       if (allow_trailing_junk) {
-        current = junk_begin; 
+        current = junk_begin;
         goto parsing_done;
       } else {
         return junk_string_value_;
@@ -1072,8 +1072,8 @@ double StringToDoubleConverter::StringToIeee(
     result = RadixStringToIeee<3>(&start,
                                   buffer + buffer_pos,
                                   sign,
-                                  separator_, 
-                                  false, // Don't parse as hex_float. 
+                                  separator_,
+                                  false, // Don't parse as hex_float.
                                   allow_trailing_junk,
                                   junk_string_value_,
                                   read_as_double,
diff --git a/contrib/libs/double-conversion/double-conversion.h b/contrib/libs/double-conversion/double-conversion.h
index 2d91e2e479..6dbc0997c6 100644
--- a/contrib/libs/double-conversion/double-conversion.h
+++ b/contrib/libs/double-conversion/double-conversion.h
@@ -294,18 +294,18 @@ class DoubleToStringConverter {
   // should be at least kBase10MaximalLength + 1 characters long.
   static const int kBase10MaximalLength = 17;
 
-  // Converts the given double 'v' to digit characters. 'v' must not be NaN, 
-  // +Infinity, or -Infinity. In SHORTEST_SINGLE-mode this restriction also 
-  // applies to 'v' after it has been casted to a single-precision float. That 
-  // is, in this mode static_cast<float>(v) must not be NaN, +Infinity or 
-  // -Infinity. 
+  // Converts the given double 'v' to digit characters. 'v' must not be NaN,
+  // +Infinity, or -Infinity. In SHORTEST_SINGLE-mode this restriction also
+  // applies to 'v' after it has been casted to a single-precision float. That
+  // is, in this mode static_cast<float>(v) must not be NaN, +Infinity or
+  // -Infinity.
   //
   // The result should be interpreted as buffer * 10^(point-length).
   //
-  // The digits are written to the buffer in the platform's charset, which is 
-  // often UTF-8 (with ASCII-range digits) but may be another charset, such 
-  // as EBCDIC. 
-  // 
+  // The digits are written to the buffer in the platform's charset, which is
+  // often UTF-8 (with ASCII-range digits) but may be another charset, such
+  // as EBCDIC.
+  //
   // The output depends on the given mode:
   //  - SHORTEST: produce the least amount of digits for which the internal
   //   identity requirement is still satisfied. If the digits are printed
@@ -379,7 +379,7 @@ class DoubleToStringConverter {
   const int max_leading_padding_zeroes_in_precision_mode_;
   const int max_trailing_padding_zeroes_in_precision_mode_;
 
-  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter); 
+  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter);
 };
 
 
@@ -394,13 +394,13 @@ class StringToDoubleConverter {
     ALLOW_TRAILING_JUNK = 4,
     ALLOW_LEADING_SPACES = 8,
     ALLOW_TRAILING_SPACES = 16,
-    ALLOW_SPACES_AFTER_SIGN = 32, 
-    ALLOW_CASE_INSENSIBILITY = 64, 
-    ALLOW_HEX_FLOATS = 128, 
+    ALLOW_SPACES_AFTER_SIGN = 32,
+    ALLOW_CASE_INSENSIBILITY = 64,
+    ALLOW_HEX_FLOATS = 128,
   };
 
-  static const uc16 kNoSeparator = '\0'; 
- 
+  static const uc16 kNoSeparator = '\0';
+
   // Flags should be a bit-or combination of the possible Flags-enum.
   //  - NO_FLAGS: no special flags.
   //  - ALLOW_HEX: recognizes the prefix "0x". Hex numbers may only be integers.
@@ -430,13 +430,13 @@ class StringToDoubleConverter {
   //  - ALLOW_SPACES_AFTER_SIGN: ignore whitespace after the sign.
   //       Ex: StringToDouble("-   123.2") -> -123.2.
   //           StringToDouble("+   123.2") -> 123.2
-  //  - ALLOW_CASE_INSENSIBILITY: ignore case of characters for special values: 
-  //      infinity and nan. 
-  //  - ALLOW_HEX_FLOATS: allows hexadecimal float literals. 
-  //      This *must* start with "0x" and separate the exponent with "p". 
-  //      Examples: 0x1.2p3 == 9.0 
-  //                0x10.1p0 == 16.0625 
-  //      ALLOW_HEX and ALLOW_HEX_FLOATS are indendent. 
+  //  - ALLOW_CASE_INSENSIBILITY: ignore case of characters for special values:
+  //      infinity and nan.
+  //  - ALLOW_HEX_FLOATS: allows hexadecimal float literals.
+  //      This *must* start with "0x" and separate the exponent with "p".
+  //      Examples: 0x1.2p3 == 9.0
+  //                0x10.1p0 == 16.0625
+  //      ALLOW_HEX and ALLOW_HEX_FLOATS are indendent.
   //
   // empty_string_value is returned when an empty string is given as input.
   // If ALLOW_LEADING_SPACES or ALLOW_TRAILING_SPACES are set, then a string
@@ -461,12 +461,12 @@ class StringToDoubleConverter {
   //  - they must not have the same first character.
   //  - they must not start with digits.
   //
-  // If the separator character is not kNoSeparator, then that specific 
-  // character is ignored when in between two valid digits of the significant. 
-  // It is not allowed to appear in the exponent. 
-  // It is not allowed to lead or trail the number. 
-  // It is not allowed to appear twice next to each other. 
-  // 
+  // If the separator character is not kNoSeparator, then that specific
+  // character is ignored when in between two valid digits of the significant.
+  // It is not allowed to appear in the exponent.
+  // It is not allowed to lead or trail the number.
+  // It is not allowed to appear twice next to each other.
+  //
   // Examples:
   //  flags = ALLOW_HEX | ALLOW_TRAILING_JUNK,
   //  empty_string_value = 0.0,
@@ -506,26 +506,26 @@ class StringToDoubleConverter {
   //    StringToDouble("01239E45") -> 1239e45.
   //    StringToDouble("-infinity") -> NaN  // junk_string_value.
   //    StringToDouble("NaN") -> NaN  // junk_string_value.
-  // 
-  //  flags = NO_FLAGS, 
-  //  separator = ' ': 
-  //    StringToDouble("1 2 3 4") -> 1234.0 
-  //    StringToDouble("1  2") -> NaN // junk_string_value 
-  //    StringToDouble("1 000 000.0") -> 1000000.0 
-  //    StringToDouble("1.000 000") -> 1.0 
-  //    StringToDouble("1.0e1 000") -> NaN // junk_string_value 
+  //
+  //  flags = NO_FLAGS,
+  //  separator = ' ':
+  //    StringToDouble("1 2 3 4") -> 1234.0
+  //    StringToDouble("1  2") -> NaN // junk_string_value
+  //    StringToDouble("1 000 000.0") -> 1000000.0
+  //    StringToDouble("1.000 000") -> 1.0
+  //    StringToDouble("1.0e1 000") -> NaN // junk_string_value
   StringToDoubleConverter(int flags,
                           double empty_string_value,
                           double junk_string_value,
                           const char* infinity_symbol,
-                          const char* nan_symbol, 
-                          uc16 separator = kNoSeparator) 
+                          const char* nan_symbol,
+                          uc16 separator = kNoSeparator)
       : flags_(flags),
         empty_string_value_(empty_string_value),
         junk_string_value_(junk_string_value),
         infinity_symbol_(infinity_symbol),
-        nan_symbol_(nan_symbol), 
-        separator_(separator) { 
+        nan_symbol_(nan_symbol),
+        separator_(separator) {
   }
 
   // Performs the conversion.
@@ -560,7 +560,7 @@ class StringToDoubleConverter {
   const double junk_string_value_;
   const char* const infinity_symbol_;
   const char* const nan_symbol_;
-  const uc16 separator_; 
+  const uc16 separator_;
 
   template <class Iterator>
   double StringToIeee(Iterator start_pointer,
@@ -568,7 +568,7 @@ class StringToDoubleConverter {
                       bool read_as_double,
                       int* processed_characters_count) const;
 
-  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter); 
+  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter);
 };
 
 }  // namespace double_conversion
diff --git a/contrib/libs/double-conversion/fixed-dtoa.cc b/contrib/libs/double-conversion/fixed-dtoa.cc
index 7af78bfe81..0f989bceaf 100644
--- a/contrib/libs/double-conversion/fixed-dtoa.cc
+++ b/contrib/libs/double-conversion/fixed-dtoa.cc
@@ -25,7 +25,7 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <cmath> 
+#include <cmath>
 
 #include "fixed-dtoa.h"
 #include "ieee.h"
diff --git a/contrib/libs/double-conversion/ieee.h b/contrib/libs/double-conversion/ieee.h
index 2038d7974b..4a5fe8f9c0 100644
--- a/contrib/libs/double-conversion/ieee.h
+++ b/contrib/libs/double-conversion/ieee.h
@@ -257,7 +257,7 @@ class Double {
         (biased_exponent << kPhysicalSignificandSize);
   }
 
-  DC_DISALLOW_COPY_AND_ASSIGN(Double); 
+  DC_DISALLOW_COPY_AND_ASSIGN(Double);
 };
 
 class Single {
@@ -394,7 +394,7 @@ class Single {
 
   const uint32_t d32_;
 
-  DC_DISALLOW_COPY_AND_ASSIGN(Single); 
+  DC_DISALLOW_COPY_AND_ASSIGN(Single);
 };
 
 }  // namespace double_conversion
diff --git a/contrib/libs/double-conversion/strtod.cc b/contrib/libs/double-conversion/strtod.cc
index 193a3b0fac..a75cf5d9f1 100644
--- a/contrib/libs/double-conversion/strtod.cc
+++ b/contrib/libs/double-conversion/strtod.cc
@@ -25,13 +25,13 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include <climits> 
-#include <cstdarg> 
+#include <climits>
+#include <cstdarg>
 
 #include "bignum.h"
 #include "cached-powers.h"
 #include "ieee.h"
-#include "strtod.h" 
+#include "strtod.h"
 
 namespace double_conversion {
 
@@ -205,7 +205,7 @@ static bool DoubleStrtod(Vector<const char> trimmed,
   // Note that the ARM simulator is compiled for 32bits. It therefore exhibits
   // the same problem.
   return false;
-#else 
+#else
   if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
     int read_digits;
     // The trimmed input fits into a double.
@@ -243,7 +243,7 @@ static bool DoubleStrtod(Vector<const char> trimmed,
     }
   }
   return false;
-#endif 
+#endif
 }
 
 
@@ -472,30 +472,30 @@ double Strtod(Vector<const char> buffer, int exponent) {
   }
 }
 
-static float SanitizedDoubletof(double d) { 
-  ASSERT(d >= 0.0); 
-  // ASAN has a sanitize check that disallows casting doubles to floats if 
-  // they are too big. 
-  // https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html#available-checks 
-  // The behavior should be covered by IEEE 754, but some projects use this 
-  // flag, so work around it. 
-  float max_finite = 3.4028234663852885981170418348451692544e+38; 
-  // The half-way point between the max-finite and infinity value. 
-  // Since infinity has an even significand everything equal or greater than 
-  // this value should become infinity. 
-  double half_max_finite_infinity = 
-      3.40282356779733661637539395458142568448e+38; 
-  if (d >= max_finite) { 
-    if (d >= half_max_finite_infinity) { 
-      return Single::Infinity(); 
-    } else { 
-      return max_finite; 
-    } 
-  } else { 
-    return static_cast<float>(d); 
-  } 
-} 
- 
+static float SanitizedDoubletof(double d) {
+  ASSERT(d >= 0.0);
+  // ASAN has a sanitize check that disallows casting doubles to floats if
+  // they are too big.
+  // https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html#available-checks
+  // The behavior should be covered by IEEE 754, but some projects use this
+  // flag, so work around it.
+  float max_finite = 3.4028234663852885981170418348451692544e+38;
+  // The half-way point between the max-finite and infinity value.
+  // Since infinity has an even significand everything equal or greater than
+  // this value should become infinity.
+  double half_max_finite_infinity =
+      3.40282356779733661637539395458142568448e+38;
+  if (d >= max_finite) {
+    if (d >= half_max_finite_infinity) {
+      return Single::Infinity();
+    } else {
+      return max_finite;
+    }
+  } else {
+    return static_cast<float>(d);
+  }
+}
+
 float Strtof(Vector<const char> buffer, int exponent) {
   char copy_buffer[kMaxSignificantDecimalDigits];
   Vector<const char> trimmed;
@@ -507,7 +507,7 @@ float Strtof(Vector<const char> buffer, int exponent) {
   double double_guess;
   bool is_correct = ComputeGuess(trimmed, exponent, &double_guess);
 
-  float float_guess = SanitizedDoubletof(double_guess); 
+  float float_guess = SanitizedDoubletof(double_guess);
   if (float_guess == double_guess) {
     // This shortcut triggers for integer values.
     return float_guess;
@@ -530,15 +530,15 @@ float Strtof(Vector<const char> buffer, int exponent) {
   double double_next = Double(double_guess).NextDouble();
   double double_previous = Double(double_guess).PreviousDouble();
 
-  float f1 = SanitizedDoubletof(double_previous); 
+  float f1 = SanitizedDoubletof(double_previous);
   float f2 = float_guess;
-  float f3 = SanitizedDoubletof(double_next); 
+  float f3 = SanitizedDoubletof(double_next);
   float f4;
   if (is_correct) {
     f4 = f3;
   } else {
     double double_next2 = Double(double_next).NextDouble();
-    f4 = SanitizedDoubletof(double_next2); 
+    f4 = SanitizedDoubletof(double_next2);
   }
   (void) f2;  // Mark variable as used.
   ASSERT(f1 <= f2 && f2 <= f3 && f3 <= f4);
@@ -553,7 +553,7 @@ float Strtof(Vector<const char> buffer, int exponent) {
          (f1 == f2 && f2 != f3 && f3 == f4) ||
          (f1 == f2 && f2 == f3 && f3 != f4));
 
-  // guess and next are the two possible candidates (in the same way that 
+  // guess and next are the two possible candidates (in the same way that
   // double_guess was the lower candidate for a double-precision guess).
   float guess = f1;
   float next = f4;
diff --git a/contrib/libs/double-conversion/utils.h b/contrib/libs/double-conversion/utils.h
index 4beac855a5..41c5b02d2c 100644
--- a/contrib/libs/double-conversion/utils.h
+++ b/contrib/libs/double-conversion/utils.h
@@ -28,10 +28,10 @@
 #ifndef DOUBLE_CONVERSION_UTILS_H_
 #define DOUBLE_CONVERSION_UTILS_H_
 
-#include <cstdlib> 
-#include <cstring> 
+#include <cstdlib>
+#include <cstring>
 
-#include <cassert> 
+#include <cassert>
 #ifndef ASSERT
 #define ASSERT(condition)         \
     assert(condition);
@@ -67,24 +67,24 @@ inline void abort_noreturn() { abort(); }
 // the output of the division with the expected result. (Inlining must be
 // disabled.)
 // On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
-// 
-// For example: 
-/* 
-// -- in div.c 
-double Div_double(double x, double y) { return x / y; } 
- 
-// -- in main.c 
-double Div_double(double x, double y);  // Forward declaration. 
- 
-int main(int argc, char** argv) { 
-  return Div_double(89255.0, 1e22) == 89255e-22; 
-} 
-*/ 
-// Run as follows ./main || echo "correct" 
-// 
-// If it prints "correct" then the architecture should be here, in the "correct" section. 
+//
+// For example:
+/*
+// -- in div.c
+double Div_double(double x, double y) { return x / y; }
+
+// -- in main.c
+double Div_double(double x, double y);  // Forward declaration.
+
+int main(int argc, char** argv) {
+  return Div_double(89255.0, 1e22) == 89255e-22;
+}
+*/
+// Run as follows ./main || echo "correct"
+//
+// If it prints "correct" then the architecture should be here, in the "correct" section.
 #if defined(_M_X64) || defined(__x86_64__) || \
-    defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \ 
+    defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \
     defined(__hppa__) || defined(__ia64__) || \
     defined(__mips__) || \
     defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
@@ -92,12 +92,12 @@ int main(int argc, char** argv) {
     defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
     defined(__SH4__) || defined(__alpha__) || \
     defined(_MIPS_ARCH_MIPS32R2) || \
-    defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \ 
-    defined(__riscv) || \ 
-    defined(__or1k__) 
+    defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \
+    defined(__riscv) || \
+    defined(__or1k__)
 #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
-#elif defined(__mc68000__) || \ 
-    defined(__pnacl__) || defined(__native_client__) 
+#elif defined(__mc68000__) || \
+    defined(__pnacl__) || defined(__native_client__)
 #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
 #elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
 #if defined(_WIN32)
@@ -148,8 +148,8 @@ typedef uint16_t uc16;
 
 // A macro to disallow the evil copy constructor and operator= functions
 // This should be used in the private: declarations for a class
-#ifndef DC_DISALLOW_COPY_AND_ASSIGN 
-#define DC_DISALLOW_COPY_AND_ASSIGN(TypeName)      \ 
+#ifndef DC_DISALLOW_COPY_AND_ASSIGN
+#define DC_DISALLOW_COPY_AND_ASSIGN(TypeName)      \
   TypeName(const TypeName&);                    \
   void operator=(const TypeName&)
 #endif
@@ -160,10 +160,10 @@ typedef uint16_t uc16;
 // This should be used in the private: declarations for a class
 // that wants to prevent anyone from instantiating it. This is
 // especially useful for classes containing only static methods.
-#ifndef DC_DISALLOW_IMPLICIT_CONSTRUCTORS 
-#define DC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ 
+#ifndef DC_DISALLOW_IMPLICIT_CONSTRUCTORS
+#define DC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
   TypeName();                                    \
-  DC_DISALLOW_COPY_AND_ASSIGN(TypeName) 
+  DC_DISALLOW_COPY_AND_ASSIGN(TypeName)
 #endif
 
 namespace double_conversion {
@@ -305,7 +305,7 @@ class StringBuilder {
 
   bool is_finalized() const { return position_ < 0; }
 
-  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder); 
+  DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
 };
 
 // The type-based aliasing rule allows the compiler to assume that pointers of
@@ -336,12 +336,12 @@ template <class Dest, class Source>
 inline Dest BitCast(const Source& source) {
   // Compile time assertion: sizeof(Dest) == sizeof(Source)
   // A compile error here means your Dest and Source have different sizes.
-#if __cplusplus >= 201103L 
-  static_assert(sizeof(Dest) == sizeof(Source), 
-                "source and destination size mismatch"); 
-#else 
-  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1]; 
-#endif 
+#if __cplusplus >= 201103L
+  static_assert(sizeof(Dest) == sizeof(Source),
+                "source and destination size mismatch");
+#else
+  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
+#endif
 
   Dest dest;
   memmove(&dest, &source, sizeof(dest));
diff --git a/contrib/libs/double-conversion/ya.make b/contrib/libs/double-conversion/ya.make
index 81321f3646..52e59b0989 100644
--- a/contrib/libs/double-conversion/ya.make
+++ b/contrib/libs/double-conversion/ya.make
@@ -12,8 +12,8 @@ OWNER(
     g:cpp-contrib
 )
 
-NO_COMPILER_WARNINGS() 
- 
+NO_COMPILER_WARNINGS()
+
 NO_UTIL()
 
 ADDINCL(GLOBAL contrib/libs/double-conversion/include)