_ZN17double_conversion6Bignum8RawBigitEi:
   36|  1.09M|Bignum::Chunk& Bignum::RawBigit(const int index) {
   37|  1.09M|  DOUBLE_CONVERSION_ASSERT(static_cast<unsigned>(index) < kBigitCapacity);
  ------------------
  |  |   47|  1.09M|    assert(condition)
  ------------------
  |  Branch (37:3): [True: 1.09M, False: 0]
  ------------------
   38|  1.09M|  return bigits_buffer_[index];
   39|  1.09M|}
_ZNK17double_conversion6Bignum8RawBigitEi:
   42|  20.1k|const Bignum::Chunk& Bignum::RawBigit(const int index) const {
   43|  20.1k|  DOUBLE_CONVERSION_ASSERT(static_cast<unsigned>(index) < kBigitCapacity);
  ------------------
  |  |   47|  20.1k|    assert(condition)
  ------------------
  |  Branch (43:3): [True: 20.1k, False: 0]
  ------------------
   44|  20.1k|  return bigits_buffer_[index];
   45|  20.1k|}
_ZN17double_conversion6Bignum12AssignUInt64Em:
   65|  3.34k|void Bignum::AssignUInt64(uint64_t value) {
   66|  3.34k|  Zero();
   67|  10.9k|  for(int i = 0; value > 0; ++i) {
  ------------------
  |  Branch (67:18): [True: 7.58k, False: 3.34k]
  ------------------
   68|  7.58k|    RawBigit(i) = value & kBigitMask;
   69|  7.58k|    value >>= kBigitSize;
   70|  7.58k|    ++used_bigits_;
   71|  7.58k|  }
   72|  3.34k|}
_ZN17double_conversion6Bignum19AssignDecimalStringENS_6VectorIKcEE:
   97|    753|void Bignum::AssignDecimalString(const Vector<const char> value) {
   98|       |  // 2^64 = 18446744073709551616 > 10^19
   99|    753|  static const int kMaxUint64DecimalDigits = 19;
  100|    753|  Zero();
  101|    753|  int length = value.length();
  102|    753|  unsigned pos = 0;
  103|       |  // Let's just say that each digit needs 4 bits.
  104|  4.25k|  while (length >= kMaxUint64DecimalDigits) {
  ------------------
  |  Branch (104:10): [True: 3.50k, False: 753]
  ------------------
  105|  3.50k|    const uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
  106|  3.50k|    pos += kMaxUint64DecimalDigits;
  107|  3.50k|    length -= kMaxUint64DecimalDigits;
  108|  3.50k|    MultiplyByPowerOfTen(kMaxUint64DecimalDigits);
  109|  3.50k|    AddUInt64(digits);
  110|  3.50k|  }
  111|    753|  const uint64_t digits = ReadUInt64(value, pos, length);
  112|    753|  MultiplyByPowerOfTen(length);
  113|    753|  AddUInt64(digits);
  114|    753|  Clamp();
  115|    753|}
_ZN17double_conversion6Bignum9AddUInt64Em:
  156|  4.25k|void Bignum::AddUInt64(const uint64_t operand) {
  157|  4.25k|  if (operand == 0) {
  ------------------
  |  Branch (157:7): [True: 1.66k, False: 2.58k]
  ------------------
  158|  1.66k|    return;
  159|  1.66k|  }
  160|  2.58k|  Bignum other;
  161|  2.58k|  other.AssignUInt64(operand);
  162|  2.58k|  AddBignum(other);
  163|  2.58k|}
_ZN17double_conversion6Bignum9AddBignumERKS0_:
  166|  2.58k|void Bignum::AddBignum(const Bignum& other) {
  167|  2.58k|  DOUBLE_CONVERSION_ASSERT(IsClamped());
  ------------------
  |  |   47|  2.58k|    assert(condition)
  ------------------
  |  Branch (167:3): [True: 2.58k, False: 0]
  ------------------
  168|  2.58k|  DOUBLE_CONVERSION_ASSERT(other.IsClamped());
  ------------------
  |  |   47|  2.58k|    assert(condition)
  ------------------
  |  Branch (168:3): [True: 2.58k, False: 0]
  ------------------
  169|       |
  170|       |  // If this has a greater exponent than other append zero-bigits to this.
  171|       |  // After this call exponent_ <= other.exponent_.
  172|  2.58k|  Align(other);
  173|       |
  174|       |  // There are two possibilities:
  175|       |  //   aaaaaaaaaaa 0000  (where the 0s represent a's exponent)
  176|       |  //     bbbbb 00000000
  177|       |  //   ----------------
  178|       |  //   ccccccccccc 0000
  179|       |  // or
  180|       |  //    aaaaaaaaaa 0000
  181|       |  //  bbbbbbbbb 0000000
  182|       |  //  -----------------
  183|       |  //  cccccccccccc 0000
  184|       |  // In both cases we might need a carry bigit.
  185|       |
  186|  2.58k|  EnsureCapacity(1 + (std::max)(BigitLength(), other.BigitLength()) - exponent_);
  187|  2.58k|  Chunk carry = 0;
  188|  2.58k|  int bigit_pos = other.exponent_ - exponent_;
  189|  2.58k|  DOUBLE_CONVERSION_ASSERT(bigit_pos >= 0);
  ------------------
  |  |   47|  2.58k|    assert(condition)
  ------------------
  |  Branch (189:3): [True: 2.58k, False: 0]
  ------------------
  190|  2.58k|  for (int i = used_bigits_; i < bigit_pos; ++i) {
  ------------------
  |  Branch (190:30): [True: 0, False: 2.58k]
  ------------------
  191|      0|    RawBigit(i) = 0;
  192|      0|  }
  193|  8.69k|  for (int i = 0; i < other.used_bigits_; ++i) {
  ------------------
  |  Branch (193:19): [True: 6.10k, False: 2.58k]
  ------------------
  194|  6.10k|    const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0;
  ------------------
  |  Branch (194:22): [True: 4.38k, False: 1.71k]
  ------------------
  195|  6.10k|    const Chunk sum = my + other.RawBigit(i) + carry;
  196|  6.10k|    RawBigit(bigit_pos) = sum & kBigitMask;
  197|  6.10k|    carry = sum >> kBigitSize;
  198|  6.10k|    ++bigit_pos;
  199|  6.10k|  }
  200|  2.96k|  while (carry != 0) {
  ------------------
  |  Branch (200:10): [True: 371, False: 2.58k]
  ------------------
  201|    371|    const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0;
  ------------------
  |  Branch (201:22): [True: 371, False: 0]
  ------------------
  202|    371|    const Chunk sum = my + carry;
  203|    371|    RawBigit(bigit_pos) = sum & kBigitMask;
  204|    371|    carry = sum >> kBigitSize;
  205|    371|    ++bigit_pos;
  206|    371|  }
  207|  2.58k|  used_bigits_ = static_cast<int16_t>(std::max(bigit_pos, static_cast<int>(used_bigits_)));
  208|       |  DOUBLE_CONVERSION_ASSERT(IsClamped());
  ------------------
  |  |   47|  2.58k|    assert(condition)
  ------------------
  |  Branch (208:3): [True: 2.58k, False: 0]
  ------------------
  209|  2.58k|}
_ZN17double_conversion6Bignum9ShiftLeftEi:
  239|  4.67k|void Bignum::ShiftLeft(const int shift_amount) {
  240|  4.67k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (240:7): [True: 0, False: 4.67k]
  ------------------
  241|      0|    return;
  242|      0|  }
  243|  4.67k|  exponent_ += static_cast<int16_t>(shift_amount / kBigitSize);
  244|  4.67k|  const int local_shift = shift_amount % kBigitSize;
  245|  4.67k|  EnsureCapacity(used_bigits_ + 1);
  246|  4.67k|  BigitsShiftLeft(local_shift);
  247|  4.67k|}
_ZN17double_conversion6Bignum16MultiplyByUInt32Ej:
  250|  7.30k|void Bignum::MultiplyByUInt32(const uint32_t factor) {
  251|  7.30k|  if (factor == 1) {
  ------------------
  |  Branch (251:7): [True: 0, False: 7.30k]
  ------------------
  252|      0|    return;
  253|      0|  }
  254|  7.30k|  if (factor == 0) {
  ------------------
  |  Branch (254:7): [True: 0, False: 7.30k]
  ------------------
  255|      0|    Zero();
  256|      0|    return;
  257|      0|  }
  258|  7.30k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (258:7): [True: 0, False: 7.30k]
  ------------------
  259|      0|    return;
  260|      0|  }
  261|       |  // The product of a bigit with the factor is of size kBigitSize + 32.
  262|       |  // Assert that this number + 1 (for the carry) fits into double chunk.
  263|  7.30k|  DOUBLE_CONVERSION_ASSERT(kDoubleChunkSize >= kBigitSize + 32 + 1);
  ------------------
  |  |   47|  7.30k|    assert(condition)
  ------------------
  |  Branch (263:3): [True: 7.30k, Folded]
  ------------------
  264|  7.30k|  DoubleChunk carry = 0;
  265|   219k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (265:19): [True: 212k, False: 7.30k]
  ------------------
  266|   212k|    const DoubleChunk product = static_cast<DoubleChunk>(factor) * RawBigit(i) + carry;
  267|   212k|    RawBigit(i) = static_cast<Chunk>(product & kBigitMask);
  268|   212k|    carry = (product >> kBigitSize);
  269|   212k|  }
  270|  12.9k|  while (carry != 0) {
  ------------------
  |  Branch (270:10): [True: 5.65k, False: 7.30k]
  ------------------
  271|  5.65k|    EnsureCapacity(used_bigits_ + 1);
  272|  5.65k|    RawBigit(used_bigits_) = carry & kBigitMask;
  273|  5.65k|    used_bigits_++;
  274|  5.65k|    carry >>= kBigitSize;
  275|  5.65k|  }
  276|  7.30k|}
_ZN17double_conversion6Bignum16MultiplyByUInt64Em:
  279|  4.52k|void Bignum::MultiplyByUInt64(const uint64_t factor) {
  280|  4.52k|  if (factor == 1) {
  ------------------
  |  Branch (280:7): [True: 0, False: 4.52k]
  ------------------
  281|      0|    return;
  282|      0|  }
  283|  4.52k|  if (factor == 0) {
  ------------------
  |  Branch (283:7): [True: 0, False: 4.52k]
  ------------------
  284|      0|    Zero();
  285|      0|    return;
  286|      0|  }
  287|  4.52k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (287:7): [True: 0, False: 4.52k]
  ------------------
  288|      0|    return;
  289|      0|  }
  290|  4.52k|  DOUBLE_CONVERSION_ASSERT(kBigitSize < 32);
  ------------------
  |  |   47|  4.52k|    assert(condition)
  ------------------
  |  Branch (290:3): [True: 4.52k, Folded]
  ------------------
  291|  4.52k|  uint64_t carry = 0;
  292|  4.52k|  const uint64_t low = factor & 0xFFFFFFFF;
  293|  4.52k|  const uint64_t high = factor >> 32;
  294|  91.3k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (294:19): [True: 86.8k, False: 4.52k]
  ------------------
  295|  86.8k|    const uint64_t product_low = low * RawBigit(i);
  296|  86.8k|    const uint64_t product_high = high * RawBigit(i);
  297|  86.8k|    const uint64_t tmp = (carry & kBigitMask) + product_low;
  298|  86.8k|    RawBigit(i) = tmp & kBigitMask;
  299|  86.8k|    carry = (carry >> kBigitSize) + (tmp >> kBigitSize) +
  300|  86.8k|        (product_high << (32 - kBigitSize));
  301|  86.8k|  }
  302|  14.7k|  while (carry != 0) {
  ------------------
  |  Branch (302:10): [True: 10.1k, False: 4.52k]
  ------------------
  303|  10.1k|    EnsureCapacity(used_bigits_ + 1);
  304|  10.1k|    RawBigit(used_bigits_) = carry & kBigitMask;
  305|  10.1k|    used_bigits_++;
  306|  10.1k|    carry >>= kBigitSize;
  307|  10.1k|  }
  308|  4.52k|}
_ZN17double_conversion6Bignum20MultiplyByPowerOfTenEi:
  311|  5.01k|void Bignum::MultiplyByPowerOfTen(const int exponent) {
  312|  5.01k|  static const uint64_t kFive27 = DOUBLE_CONVERSION_UINT64_2PART_C(0x6765c793, fa10079d);
  ------------------
  |  |  195|  5.01k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  313|  5.01k|  static const uint16_t kFive1 = 5;
  314|  5.01k|  static const uint16_t kFive2 = kFive1 * 5;
  315|  5.01k|  static const uint16_t kFive3 = kFive2 * 5;
  316|  5.01k|  static const uint16_t kFive4 = kFive3 * 5;
  317|  5.01k|  static const uint16_t kFive5 = kFive4 * 5;
  318|  5.01k|  static const uint16_t kFive6 = kFive5 * 5;
  319|  5.01k|  static const uint32_t kFive7 = kFive6 * 5;
  320|  5.01k|  static const uint32_t kFive8 = kFive7 * 5;
  321|  5.01k|  static const uint32_t kFive9 = kFive8 * 5;
  322|  5.01k|  static const uint32_t kFive10 = kFive9 * 5;
  323|  5.01k|  static const uint32_t kFive11 = kFive10 * 5;
  324|  5.01k|  static const uint32_t kFive12 = kFive11 * 5;
  325|  5.01k|  static const uint32_t kFive13 = kFive12 * 5;
  326|  5.01k|  static const uint32_t kFive1_to_12[] =
  327|  5.01k|      { kFive1, kFive2, kFive3, kFive4, kFive5, kFive6,
  328|  5.01k|        kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 };
  329|       |
  330|  5.01k|  DOUBLE_CONVERSION_ASSERT(exponent >= 0);
  ------------------
  |  |   47|  5.01k|    assert(condition)
  ------------------
  |  Branch (330:3): [True: 5.01k, False: 0]
  ------------------
  331|       |
  332|  5.01k|  if (exponent == 0) {
  ------------------
  |  Branch (332:7): [True: 338, False: 4.67k]
  ------------------
  333|    338|    return;
  334|    338|  }
  335|  4.67k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (335:7): [True: 753, False: 3.91k]
  ------------------
  336|    753|    return;
  337|    753|  }
  338|       |  // We shift by exponent at the end just before returning.
  339|  3.91k|  int remaining_exponent = exponent;
  340|  8.43k|  while (remaining_exponent >= 27) {
  ------------------
  |  Branch (340:10): [True: 4.52k, False: 3.91k]
  ------------------
  341|  4.52k|    MultiplyByUInt64(kFive27);
  342|  4.52k|    remaining_exponent -= 27;
  343|  4.52k|  }
  344|  7.44k|  while (remaining_exponent >= 13) {
  ------------------
  |  Branch (344:10): [True: 3.52k, False: 3.91k]
  ------------------
  345|  3.52k|    MultiplyByUInt32(kFive13);
  346|  3.52k|    remaining_exponent -= 13;
  347|  3.52k|  }
  348|  3.91k|  if (remaining_exponent > 0) {
  ------------------
  |  Branch (348:7): [True: 3.78k, False: 137]
  ------------------
  349|  3.78k|    MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]);
  350|  3.78k|  }
  351|  3.91k|  ShiftLeft(exponent);
  352|  3.91k|}
_ZNK17double_conversion6Bignum11BigitOrZeroEi:
  633|  5.85k|Bignum::Chunk Bignum::BigitOrZero(const int index) const {
  634|  5.85k|  if (index >= BigitLength()) {
  ------------------
  |  Branch (634:7): [True: 0, False: 5.85k]
  ------------------
  635|      0|    return 0;
  636|      0|  }
  637|  5.85k|  if (index < exponent_) {
  ------------------
  |  Branch (637:7): [True: 293, False: 5.56k]
  ------------------
  638|    293|    return 0;
  639|    293|  }
  640|  5.56k|  return RawBigit(index - exponent_);
  641|  5.85k|}
_ZN17double_conversion6Bignum7CompareERKS0_S2_:
  644|    753|int Bignum::Compare(const Bignum& a, const Bignum& b) {
  645|    753|  DOUBLE_CONVERSION_ASSERT(a.IsClamped());
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (645:3): [True: 753, False: 0]
  ------------------
  646|    753|  DOUBLE_CONVERSION_ASSERT(b.IsClamped());
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (646:3): [True: 753, False: 0]
  ------------------
  647|    753|  const int bigit_length_a = a.BigitLength();
  648|    753|  const int bigit_length_b = b.BigitLength();
  649|    753|  if (bigit_length_a < bigit_length_b) {
  ------------------
  |  Branch (649:7): [True: 6, False: 747]
  ------------------
  650|      6|    return -1;
  651|      6|  }
  652|    747|  if (bigit_length_a > bigit_length_b) {
  ------------------
  |  Branch (652:7): [True: 0, False: 747]
  ------------------
  653|      0|    return +1;
  654|      0|  }
  655|  3.02k|  for (int i = bigit_length_a - 1; i >= (std::min)(a.exponent_, b.exponent_); --i) {
  ------------------
  |  Branch (655:36): [True: 2.92k, False: 93]
  ------------------
  656|  2.92k|    const Chunk bigit_a = a.BigitOrZero(i);
  657|  2.92k|    const Chunk bigit_b = b.BigitOrZero(i);
  658|  2.92k|    if (bigit_a < bigit_b) {
  ------------------
  |  Branch (658:9): [True: 220, False: 2.70k]
  ------------------
  659|    220|      return -1;
  660|    220|    }
  661|  2.70k|    if (bigit_a > bigit_b) {
  ------------------
  |  Branch (661:9): [True: 434, False: 2.27k]
  ------------------
  662|    434|      return +1;
  663|    434|    }
  664|       |    // Otherwise they are equal up to this digit. Try the next digit.
  665|  2.70k|  }
  666|     93|  return 0;
  667|    747|}
_ZN17double_conversion6Bignum5ClampEv:
  715|    753|void Bignum::Clamp() {
  716|    753|  while (used_bigits_ > 0 && RawBigit(used_bigits_ - 1) == 0) {
  ------------------
  |  Branch (716:10): [True: 753, False: 0]
  |  Branch (716:30): [True: 0, False: 753]
  ------------------
  717|      0|    used_bigits_--;
  718|      0|  }
  719|    753|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (719:7): [True: 0, False: 753]
  ------------------
  720|       |    // Zero.
  721|      0|    exponent_ = 0;
  722|      0|  }
  723|    753|}
_ZN17double_conversion6Bignum5AlignERKS0_:
  726|  2.58k|void Bignum::Align(const Bignum& other) {
  727|  2.58k|  if (exponent_ > other.exponent_) {
  ------------------
  |  Branch (727:7): [True: 0, False: 2.58k]
  ------------------
  728|       |    // If "X" represents a "hidden" bigit (by the exponent) then we are in the
  729|       |    // following case (a == this, b == other):
  730|       |    // a:  aaaaaaXXXX   or a:   aaaaaXXX
  731|       |    // b:     bbbbbbX      b: bbbbbbbbXX
  732|       |    // We replace some of the hidden digits (X) of a with 0 digits.
  733|       |    // a:  aaaaaa000X   or a:   aaaaa0XX
  734|      0|    const int zero_bigits = exponent_ - other.exponent_;
  735|      0|    EnsureCapacity(used_bigits_ + zero_bigits);
  736|      0|    for (int i = used_bigits_ - 1; i >= 0; --i) {
  ------------------
  |  Branch (736:36): [True: 0, False: 0]
  ------------------
  737|      0|      RawBigit(i + zero_bigits) = RawBigit(i);
  738|      0|    }
  739|      0|    for (int i = 0; i < zero_bigits; ++i) {
  ------------------
  |  Branch (739:21): [True: 0, False: 0]
  ------------------
  740|      0|      RawBigit(i) = 0;
  741|      0|    }
  742|      0|    used_bigits_ += static_cast<int16_t>(zero_bigits);
  743|      0|    exponent_ -= static_cast<int16_t>(zero_bigits);
  744|       |
  745|      0|    DOUBLE_CONVERSION_ASSERT(used_bigits_ >= 0);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (745:5): [True: 0, False: 0]
  ------------------
  746|      0|    DOUBLE_CONVERSION_ASSERT(exponent_ >= 0);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (746:5): [True: 0, False: 0]
  ------------------
  747|      0|  }
  748|  2.58k|}
_ZN17double_conversion6Bignum15BigitsShiftLeftEi:
  751|  4.67k|void Bignum::BigitsShiftLeft(const int shift_amount) {
  752|  4.67k|  DOUBLE_CONVERSION_ASSERT(shift_amount < kBigitSize);
  ------------------
  |  |   47|  4.67k|    assert(condition)
  ------------------
  |  Branch (752:3): [True: 4.67k, False: 0]
  ------------------
  753|  4.67k|  DOUBLE_CONVERSION_ASSERT(shift_amount >= 0);
  ------------------
  |  |   47|  4.67k|    assert(condition)
  ------------------
  |  Branch (753:3): [True: 4.67k, False: 0]
  ------------------
  754|  4.67k|  Chunk carry = 0;
  755|   128k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (755:19): [True: 123k, False: 4.67k]
  ------------------
  756|   123k|    const Chunk new_carry = RawBigit(i) >> (kBigitSize - shift_amount);
  757|   123k|    RawBigit(i) = ((RawBigit(i) << shift_amount) + carry) & kBigitMask;
  758|   123k|    carry = new_carry;
  759|   123k|  }
  760|  4.67k|  if (carry != 0) {
  ------------------
  |  Branch (760:7): [True: 2.89k, False: 1.77k]
  ------------------
  761|  2.89k|    RawBigit(used_bigits_) = carry;
  762|  2.89k|    used_bigits_++;
  763|  2.89k|  }
  764|  4.67k|}
bignum.cc:_ZN17double_conversionL10ReadUInt64ENS_6VectorIKcEEii:
   86|  4.25k|                           const int digits_to_read) {
   87|  4.25k|  uint64_t result = 0;
   88|  76.9k|  for (int i = from; i < from + digits_to_read; ++i) {
  ------------------
  |  Branch (88:22): [True: 72.6k, False: 4.25k]
  ------------------
   89|  72.6k|    const int digit = buffer[i] - '0';
   90|  72.6k|    DOUBLE_CONVERSION_ASSERT(0 <= digit && digit <= 9);
  ------------------
  |  |   47|  72.6k|    assert(condition)
  ------------------
  |  Branch (90:5): [True: 72.6k, False: 0]
  |  Branch (90:5): [True: 72.6k, False: 0]
  |  Branch (90:5): [True: 72.6k, False: 0]
  ------------------
   91|  72.6k|    result = result * 10 + digit;
   92|  72.6k|  }
   93|  4.25k|  return result;
   94|  4.25k|}

_ZN17double_conversion6BignumC2Ev:
   42|  4.09k|  Bignum() : used_bigits_(0), exponent_(0) {}
_ZN17double_conversion6Bignum14EnsureCapacityEi:
  114|  23.1k|  static void EnsureCapacity(const int size) {
  115|  23.1k|    if (size > kBigitCapacity) {
  ------------------
  |  Branch (115:9): [True: 0, False: 23.1k]
  ------------------
  116|      0|      DOUBLE_CONVERSION_UNREACHABLE();
  ------------------
  |  |   77|      0|#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
  ------------------
  117|      0|    }
  118|  23.1k|  }
_ZNK17double_conversion6Bignum9IsClampedEv:
  121|  9.27k|  bool IsClamped() const {
  122|  9.27k|    return used_bigits_ == 0 || RawBigit(used_bigits_ - 1) != 0;
  ------------------
  |  Branch (122:12): [True: 753, False: 8.52k]
  |  Branch (122:33): [True: 8.52k, False: 0]
  ------------------
  123|  9.27k|  }
_ZN17double_conversion6Bignum4ZeroEv:
  124|  4.09k|  void Zero() {
  125|  4.09k|    used_bigits_ = 0;
  126|  4.09k|    exponent_ = 0;
  127|  4.09k|  }
_ZNK17double_conversion6Bignum11BigitLengthEv:
  133|  12.5k|  int BigitLength() const { return used_bigits_ + exponent_; }

_ZN17double_conversion16PowersOfTenCache32GetCachedPowerForDecimalExponentEiPNS_5DiyFpEPi:
  161|  1.32k|                                      int* found_exponent) {
  162|  1.32k|  DOUBLE_CONVERSION_ASSERT(kMinDecimalExponent <= requested_exponent);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (162:3): [True: 1.32k, False: 0]
  ------------------
  163|  1.32k|  DOUBLE_CONVERSION_ASSERT(requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (163:3): [True: 1.32k, False: 0]
  ------------------
  164|  1.32k|  int index =
  165|  1.32k|      (requested_exponent + kCachedPowersOffset) / kDecimalExponentDistance;
  166|  1.32k|  CachedPower cached_power = kCachedPowers[index];
  167|  1.32k|  *power = DiyFp(cached_power.significand, cached_power.binary_exponent);
  168|  1.32k|  *found_exponent = cached_power.decimal_exponent;
  169|  1.32k|  DOUBLE_CONVERSION_ASSERT(*found_exponent <= requested_exponent);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (169:3): [True: 1.32k, False: 0]
  ------------------
  170|  1.32k|  DOUBLE_CONVERSION_ASSERT(requested_exponent < *found_exponent + kDecimalExponentDistance);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (170:3): [True: 1.32k, False: 0]
  ------------------
  171|  1.32k|}

_ZN17double_conversion5DiyFpC2Ev:
   45|  2.65k|  DiyFp() : f_(0), e_(0) {}
_ZN17double_conversion5DiyFpC2Emi:
   46|  5.94k|  DiyFp(const uint64_t significand, const int32_t exponent) : f_(significand), e_(exponent) {}
_ZN17double_conversion5DiyFp8MultiplyERKS0_:
   68|  2.53k|  void Multiply(const DiyFp& other) {
   69|       |    // Simply "emulates" a 128 bit multiplication.
   70|       |    // However: the resulting number only contains 64 bits. The least
   71|       |    // significant 64 bits are only used for rounding the most significant 64
   72|       |    // bits.
   73|  2.53k|    const uint64_t kM32 = 0xFFFFFFFFU;
   74|  2.53k|    const uint64_t a = f_ >> 32;
   75|  2.53k|    const uint64_t b = f_ & kM32;
   76|  2.53k|    const uint64_t c = other.f_ >> 32;
   77|  2.53k|    const uint64_t d = other.f_ & kM32;
   78|  2.53k|    const uint64_t ac = a * c;
   79|  2.53k|    const uint64_t bc = b * c;
   80|  2.53k|    const uint64_t ad = a * d;
   81|  2.53k|    const uint64_t bd = b * d;
   82|       |    // By adding 1U << 31 to tmp we round the final result.
   83|       |    // Halfway cases will be rounded up.
   84|  2.53k|    const uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32) + (1U << 31);
   85|  2.53k|    e_ += other.e_ + 64;
   86|  2.53k|    f_ = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
   87|  2.53k|  }
_ZN17double_conversion5DiyFp9NormalizeEv:
   96|  2.65k|  void Normalize() {
   97|  2.65k|    DOUBLE_CONVERSION_ASSERT(f_ != 0);
  ------------------
  |  |   47|  2.65k|    assert(condition)
  ------------------
  |  Branch (97:5): [True: 2.65k, False: 0]
  ------------------
   98|  2.65k|    uint64_t significand = f_;
   99|  2.65k|    int32_t exponent = e_;
  100|       |
  101|       |    // This method is mainly called for normalizing boundaries. In general,
  102|       |    // boundaries need to be shifted by 10 bits, and we optimize for this case.
  103|  2.65k|    const uint64_t k10MSBits = DOUBLE_CONVERSION_UINT64_2PART_C(0xFFC00000, 00000000);
  ------------------
  |  |  195|  2.65k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  104|  5.58k|    while ((significand & k10MSBits) == 0) {
  ------------------
  |  Branch (104:12): [True: 2.93k, False: 2.65k]
  ------------------
  105|  2.93k|      significand <<= 10;
  106|  2.93k|      exponent -= 10;
  107|  2.93k|    }
  108|  6.91k|    while ((significand & kUint64MSB) == 0) {
  ------------------
  |  Branch (108:12): [True: 4.26k, False: 2.65k]
  ------------------
  109|  4.26k|      significand <<= 1;
  110|  4.26k|      exponent--;
  111|  4.26k|    }
  112|  2.65k|    f_ = significand;
  113|  2.65k|    e_ = exponent;
  114|  2.65k|  }
_ZNK17double_conversion5DiyFp1fEv:
  122|  5.05k|  uint64_t f() const { return f_; }
_ZNK17double_conversion5DiyFp1eEv:
  123|  10.8k|  int32_t e() const { return e_; }
_ZN17double_conversion5DiyFp5set_fEm:
  125|    318|  void set_f(uint64_t new_value) { f_ = new_value; }
_ZN17double_conversion5DiyFp5set_eEi:
  126|     56|  void set_e(int32_t new_value) { e_ = new_value; }

_ZN17double_conversion6Double8InfinityEv:
  236|    920|  static double Infinity() {
  237|    920|    return Double(kInfinity).value();
  238|    920|  }
_ZN17double_conversion6DoubleC2Em:
   56|  1.40k|  explicit Double(uint64_t d64) : d64_(d64) {}
_ZNK17double_conversion6Double5valueEv:
  220|  2.73k|  double value() const { return uint64_to_double(d64_); }
string-to-double.cc:_ZN17double_conversionL16uint64_to_doubleEm:
   37|      4|static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); }
_ZN17double_conversion6Double3NaNEv:
  240|      2|  static double NaN() {
  241|      2|    return Double(kNaN).value();
  242|      2|  }
_ZN17double_conversion6DoubleC2Ed:
   55|  1.32k|  explicit Double(double d) : d64_(double_to_uint64(d)) {}
_ZN17double_conversion6DoubleC2ENS_5DiyFpE:
   58|  1.32k|    : d64_(DiyFpToUint64(diy_fp)) {}
_ZNK17double_conversion6Double8AsUint64Ev:
   86|  4.82k|  uint64_t AsUint64() const {
   87|  4.82k|    return d64_;
   88|  4.82k|  }
_ZNK17double_conversion6Double10NextDoubleEv:
   91|    482|  double NextDouble() const {
   92|    482|    if (d64_ == kInfinity) return Double(kInfinity).value();
  ------------------
  |  Branch (92:9): [True: 0, False: 482]
  ------------------
   93|    482|    if (Sign() < 0 && Significand() == 0) {
  ------------------
  |  Branch (93:9): [True: 0, False: 482]
  |  Branch (93:23): [True: 0, False: 0]
  ------------------
   94|       |      // -0.0
   95|      0|      return 0.0;
   96|      0|    }
   97|    482|    if (Sign() < 0) {
  ------------------
  |  Branch (97:9): [True: 0, False: 482]
  ------------------
   98|      0|      return Double(d64_ - 1).value();
   99|    482|    } else {
  100|    482|      return Double(d64_ + 1).value();
  101|    482|    }
  102|    482|  }
_ZNK17double_conversion6Double8ExponentEv:
  114|    753|  int Exponent() const {
  115|    753|    if (IsDenormal()) return kDenormalExponent;
  ------------------
  |  Branch (115:9): [True: 92, False: 661]
  ------------------
  116|       |
  117|    661|    uint64_t d64 = AsUint64();
  118|    661|    int biased_e =
  119|    661|        static_cast<int>((d64 & kExponentMask) >> kPhysicalSignificandSize);
  120|    661|    return biased_e - kExponentBias;
  121|    753|  }
_ZNK17double_conversion6Double11SignificandEv:
  123|    846|  uint64_t Significand() const {
  124|    846|    uint64_t d64 = AsUint64();
  125|    846|    uint64_t significand = d64 & kSignificandMask;
  126|    846|    if (!IsDenormal()) {
  ------------------
  |  Branch (126:9): [True: 754, False: 92]
  ------------------
  127|    754|      return significand + kHiddenBit;
  128|    754|    } else {
  129|     92|      return significand;
  130|     92|    }
  131|    846|  }
_ZNK17double_conversion6Double10IsDenormalEv:
  134|  1.59k|  bool IsDenormal() const {
  135|  1.59k|    uint64_t d64 = AsUint64();
  136|  1.59k|    return (d64 & kExponentMask) == 0;
  137|  1.59k|  }
_ZNK17double_conversion6Double4SignEv:
  175|  1.71k|  int Sign() const {
  176|  1.71k|    uint64_t d64 = AsUint64();
  177|  1.71k|    return (d64 & kSignMask) == 0? 1: -1;
  ------------------
  |  Branch (177:12): [True: 1.71k, False: 0]
  ------------------
  178|  1.71k|  }
_ZNK17double_conversion6Double13UpperBoundaryEv:
  182|    753|  DiyFp UpperBoundary() const {
  183|    753|    DOUBLE_CONVERSION_ASSERT(Sign() > 0);
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (183:5): [True: 753, False: 0]
  ------------------
  184|    753|    return DiyFp(Significand() * 2 + 1, Exponent() - 1);
  185|    753|  }
_ZN17double_conversion6Double34SignificandSizeForOrderOfMagnitudeEi:
  228|  1.32k|  static int SignificandSizeForOrderOfMagnitude(int order) {
  229|  1.32k|    if (order >= (kDenormalExponent + kSignificandSize)) {
  ------------------
  |  Branch (229:9): [True: 1.14k, False: 182]
  ------------------
  230|  1.14k|      return kSignificandSize;
  231|  1.14k|    }
  232|    182|    if (order <= kDenormalExponent) return 0;
  ------------------
  |  Branch (232:9): [True: 35, False: 147]
  ------------------
  233|    147|    return order - kDenormalExponent;
  234|    182|  }
_ZN17double_conversion6Double13DiyFpToUint64ENS_5DiyFpE:
  256|  1.32k|  static uint64_t DiyFpToUint64(DiyFp diy_fp) {
  257|  1.32k|    uint64_t significand = diy_fp.f();
  258|  1.32k|    int exponent = diy_fp.e();
  259|  1.34k|    while (significand > kHiddenBit + kSignificandMask) {
  ------------------
  |  Branch (259:12): [True: 19, False: 1.32k]
  ------------------
  260|     19|      significand >>= 1;
  261|     19|      exponent++;
  262|     19|    }
  263|  1.32k|    if (exponent >= kMaxExponent) {
  ------------------
  |  Branch (263:9): [True: 5, False: 1.32k]
  ------------------
  264|      5|      return kInfinity;
  265|      5|    }
  266|  1.32k|    if (exponent < kDenormalExponent) {
  ------------------
  |  Branch (266:9): [True: 21, False: 1.30k]
  ------------------
  267|     21|      return 0;
  268|     21|    }
  269|  1.30k|    while (exponent > kDenormalExponent && (significand & kHiddenBit) == 0) {
  ------------------
  |  Branch (269:12): [True: 1.13k, False: 162]
  |  Branch (269:44): [True: 0, False: 1.13k]
  ------------------
  270|      0|      significand <<= 1;
  271|      0|      exponent--;
  272|      0|    }
  273|  1.30k|    uint64_t biased_exponent;
  274|  1.30k|    if (exponent == kDenormalExponent && (significand & kHiddenBit) == 0) {
  ------------------
  |  Branch (274:9): [True: 162, False: 1.13k]
  |  Branch (274:42): [True: 161, False: 1]
  ------------------
  275|    161|      biased_exponent = 0;
  276|  1.14k|    } else {
  277|  1.14k|      biased_exponent = static_cast<uint64_t>(exponent + kExponentBias);
  278|  1.14k|    }
  279|  1.30k|    return (significand & kSignificandMask) |
  280|  1.30k|        (biased_exponent << kPhysicalSignificandSize);
  281|  1.32k|  }
strtod.cc:_ZN17double_conversionL16uint64_to_doubleEm:
   37|  2.72k|static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); }
strtod.cc:_ZN17double_conversionL16double_to_uint64Ed:
   36|  1.32k|static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); }

_ZNK17double_conversion23StringToDoubleConverter14StringToDoubleEPKciPi:
  830|  2.93k|    int* processed_characters_count) const {
  831|  2.93k|  return StringToIeee(buffer, length, true, processed_characters_count);
  832|  2.93k|}
_ZNK17double_conversion23StringToDoubleConverter12StringToIeeeIPKcEEdT_ibPi:
  485|  2.93k|    int* processed_characters_count) const {
  486|  2.93k|  Iterator current = input;
  487|  2.93k|  Iterator end = input + length;
  488|       |
  489|  2.93k|  *processed_characters_count = 0;
  490|       |
  491|  2.93k|  const bool allow_trailing_junk = (flags_ & ALLOW_TRAILING_JUNK) != 0;
  492|  2.93k|  const bool allow_leading_spaces = (flags_ & ALLOW_LEADING_SPACES) != 0;
  493|  2.93k|  const bool allow_trailing_spaces = (flags_ & ALLOW_TRAILING_SPACES) != 0;
  494|  2.93k|  const bool allow_spaces_after_sign = (flags_ & ALLOW_SPACES_AFTER_SIGN) != 0;
  495|  2.93k|  const bool allow_case_insensitivity = (flags_ & ALLOW_CASE_INSENSITIVITY) != 0;
  496|       |
  497|       |  // To make sure that iterator dereferencing is valid the following
  498|       |  // convention is used:
  499|       |  // 1. Each '++current' statement is followed by check for equality to 'end'.
  500|       |  // 2. If AdvanceToNonspace returned false then current == end.
  501|       |  // 3. If 'current' becomes equal to 'end' the function returns or goes to
  502|       |  // 'parsing_done'.
  503|       |  // 4. 'current' is not dereferenced after the 'parsing_done' label.
  504|       |  // 5. Code before 'parsing_done' may rely on 'current != end'.
  505|  2.93k|  if (current == end) return empty_string_value_;
  ------------------
  |  Branch (505:7): [True: 0, False: 2.93k]
  ------------------
  506|       |
  507|  2.93k|  if (allow_leading_spaces || allow_trailing_spaces) {
  ------------------
  |  Branch (507:7): [True: 2.93k, False: 0]
  |  Branch (507:31): [True: 0, False: 0]
  ------------------
  508|  2.93k|    if (!AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (508:9): [True: 12, False: 2.92k]
  ------------------
  509|     12|      *processed_characters_count = static_cast<int>(current - input);
  510|     12|      return empty_string_value_;
  511|     12|    }
  512|  2.92k|    if (!allow_leading_spaces && (input != current)) {
  ------------------
  |  Branch (512:9): [True: 0, False: 2.92k]
  |  Branch (512:34): [True: 0, False: 0]
  ------------------
  513|       |      // No leading spaces allowed, but AdvanceToNonspace moved forward.
  514|      0|      return junk_string_value_;
  515|      0|    }
  516|  2.92k|  }
  517|       |
  518|       |  // Exponent will be adjusted if insignificant digits of the integer part
  519|       |  // or insignificant leading zeros of the fractional part are dropped.
  520|  2.92k|  int exponent = 0;
  521|       |  // Leading fractional zeros and dropped integer digits are both moved into the
  522|       |  // exponent, and both are bounded only by the input length. Saturating the
  523|       |  // accumulation at this magnitude keeps it inside int; any exponent this large
  524|       |  // is far outside the double range, so the clamped result is unchanged.
  525|  2.92k|  const int max_exponent = INT_MAX / 2;
  526|  2.92k|  int significant_digits = 0;
  527|  2.92k|  int insignificant_digits = 0;
  528|  2.92k|  bool nonzero_digit_dropped = false;
  529|       |
  530|  2.92k|  bool sign = false;
  531|       |
  532|  2.92k|  if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (532:7): [True: 10, False: 2.91k]
  |  Branch (532:26): [True: 131, False: 2.78k]
  ------------------
  533|    141|    sign = (*current == '-');
  534|    141|    ++current;
  535|    141|    Iterator next_non_space = current;
  536|       |    // Skip following spaces (if allowed).
  537|    141|    if (!AdvanceToNonspace(&next_non_space, end)) return junk_string_value_;
  ------------------
  |  Branch (537:9): [True: 16, False: 125]
  ------------------
  538|    125|    if (!allow_spaces_after_sign && (current != next_non_space)) {
  ------------------
  |  Branch (538:9): [True: 0, False: 125]
  |  Branch (538:37): [True: 0, False: 0]
  ------------------
  539|      0|      return junk_string_value_;
  540|      0|    }
  541|    125|    current = next_non_space;
  542|    125|  }
  543|       |
  544|  2.90k|  if (infinity_symbol_ != DOUBLE_CONVERSION_NULLPTR) {
  ------------------
  |  |   39|  2.90k|#define DOUBLE_CONVERSION_NULLPTR nullptr
  ------------------
  |  Branch (544:7): [True: 2.90k, False: 0]
  ------------------
  545|  2.90k|    if (ConsumeFirstCharacter(*current, infinity_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (545:9): [True: 9, False: 2.90k]
  ------------------
  546|      9|      if (!ConsumeSubString(&current, end, infinity_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (546:11): [True: 7, False: 2]
  ------------------
  547|      7|        return junk_string_value_;
  548|      7|      }
  549|       |
  550|      2|      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (550:13): [True: 2, False: 0]
  |  Branch (550:38): [True: 0, False: 0]
  |  Branch (550:62): [True: 0, False: 0]
  ------------------
  551|      0|        return junk_string_value_;
  552|      0|      }
  553|      2|      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (553:11): [True: 0, False: 2]
  |  Branch (553:35): [True: 0, False: 0]
  ------------------
  554|      0|        return junk_string_value_;
  555|      0|      }
  556|       |
  557|      2|      *processed_characters_count = static_cast<int>(current - input);
  558|      2|      return sign ? -Double::Infinity() : Double::Infinity();
  ------------------
  |  Branch (558:14): [True: 1, False: 1]
  ------------------
  559|      2|    }
  560|  2.90k|  }
  561|       |
  562|  2.90k|  if (nan_symbol_ != DOUBLE_CONVERSION_NULLPTR) {
  ------------------
  |  |   39|  2.90k|#define DOUBLE_CONVERSION_NULLPTR nullptr
  ------------------
  |  Branch (562:7): [True: 2.90k, False: 0]
  ------------------
  563|  2.90k|    if (ConsumeFirstCharacter(*current, nan_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (563:9): [True: 11, False: 2.88k]
  ------------------
  564|     11|      if (!ConsumeSubString(&current, end, nan_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (564:11): [True: 9, False: 2]
  ------------------
  565|      9|        return junk_string_value_;
  566|      9|      }
  567|       |
  568|      2|      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (568:13): [True: 2, False: 0]
  |  Branch (568:38): [True: 0, False: 0]
  |  Branch (568:62): [True: 0, False: 0]
  ------------------
  569|      0|        return junk_string_value_;
  570|      0|      }
  571|      2|      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (571:11): [True: 0, False: 2]
  |  Branch (571:35): [True: 0, False: 0]
  ------------------
  572|      0|        return junk_string_value_;
  573|      0|      }
  574|       |
  575|      2|      *processed_characters_count = static_cast<int>(current - input);
  576|      2|      return sign ? -Double::NaN() : Double::NaN();
  ------------------
  |  Branch (576:14): [True: 1, False: 1]
  ------------------
  577|      2|    }
  578|  2.90k|  }
  579|       |
  580|  2.88k|  bool leading_zero = false;
  581|  2.88k|  if (*current == '0') {
  ------------------
  |  Branch (581:7): [True: 924, False: 1.96k]
  ------------------
  582|    924|    if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (582:9): [True: 4, False: 920]
  ------------------
  583|      4|      *processed_characters_count = static_cast<int>(current - input);
  584|      4|      return SignedZero(sign);
  585|      4|    }
  586|       |
  587|    920|    leading_zero = true;
  588|       |
  589|       |    // It could be hexadecimal value.
  590|    920|    if (((flags_ & ALLOW_HEX) || (flags_ & ALLOW_HEX_FLOATS)) &&
  ------------------
  |  Branch (590:10): [True: 920, False: 0]
  |  Branch (590:34): [True: 0, False: 0]
  ------------------
  591|    920|        (*current == 'x' || *current == 'X')) {
  ------------------
  |  Branch (591:10): [True: 287, False: 633]
  |  Branch (591:29): [True: 344, False: 289]
  ------------------
  592|    631|      ++current;
  593|       |
  594|    631|      if (current == end) return junk_string_value_;  // "0x"
  ------------------
  |  Branch (594:11): [True: 2, False: 629]
  ------------------
  595|       |
  596|    629|      bool parse_as_hex_float = (flags_ & ALLOW_HEX_FLOATS) &&
  ------------------
  |  Branch (596:33): [True: 629, False: 0]
  ------------------
  597|    629|                IsHexFloatString(current, end, separator_, allow_trailing_junk,
  ------------------
  |  Branch (597:17): [True: 213, False: 416]
  ------------------
  598|    629|                                 allow_trailing_spaces);
  599|       |
  600|    629|      if (!parse_as_hex_float && !isDigit(*current, 16)) {
  ------------------
  |  Branch (600:11): [True: 416, False: 213]
  |  Branch (600:34): [True: 85, False: 331]
  ------------------
  601|     85|        return junk_string_value_;
  602|     85|      }
  603|       |
  604|    544|      bool result_is_junk;
  605|    544|      double result = RadixStringToIeee<4>(&current,
  606|    544|                                           end,
  607|    544|                                           sign,
  608|    544|                                           separator_,
  609|    544|                                           parse_as_hex_float,
  610|    544|                                           allow_trailing_junk,
  611|    544|                                           allow_trailing_spaces,
  612|    544|                                           junk_string_value_,
  613|    544|                                           read_as_double,
  614|    544|                                           &result_is_junk);
  615|    544|      if (!result_is_junk) {
  ------------------
  |  Branch (615:11): [True: 544, False: 0]
  ------------------
  616|    544|        if (allow_trailing_spaces) AdvanceToNonspace(&current, end);
  ------------------
  |  Branch (616:13): [True: 544, False: 0]
  ------------------
  617|    544|        *processed_characters_count = static_cast<int>(current - input);
  618|    544|      }
  619|    544|      return result;
  620|    629|    }
  621|       |
  622|       |    // Ignore leading zeros in the integer part.
  623|    676|    while (*current == '0') {
  ------------------
  |  Branch (623:12): [True: 395, False: 281]
  ------------------
  624|    395|      if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (624:11): [True: 8, False: 387]
  ------------------
  625|      8|        *processed_characters_count = static_cast<int>(current - input);
  626|      8|        return SignedZero(sign);
  627|      8|      }
  628|    395|    }
  629|    289|  }
  630|       |
  631|  2.24k|  bool octal = leading_zero && (flags_ & ALLOW_OCTALS) != 0;
  ------------------
  |  Branch (631:16): [True: 281, False: 1.96k]
  |  Branch (631:32): [True: 281, False: 0]
  ------------------
  632|       |
  633|       |  // The longest form of simplified number is: "-<significant digits>.1eXXX\0".
  634|  2.24k|  const int kBufferSize = kMaxSignificantDigits + 10;
  635|  2.24k|  DOUBLE_CONVERSION_STACK_UNINITIALIZED char
  ------------------
  |  |  104|  2.24k|#define DOUBLE_CONVERSION_STACK_UNINITIALIZED __attribute__((uninitialized))
  ------------------
  636|  2.24k|      buffer[kBufferSize];  // NOLINT: size is known at compile time.
  637|  2.24k|  int buffer_pos = 0;
  638|       |
  639|       |  // Copy significant digits of the integer part (if any) to the buffer.
  640|  70.0k|  while (*current >= '0' && *current <= '9') {
  ------------------
  |  Branch (640:10): [True: 69.6k, False: 496]
  |  Branch (640:29): [True: 68.6k, False: 994]
  ------------------
  641|  68.6k|    if (significant_digits < kMaxSignificantDigits) {
  ------------------
  |  Branch (641:9): [True: 68.2k, False: 400]
  ------------------
  642|  68.2k|      DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  68.2k|    assert(condition)
  ------------------
  |  Branch (642:7): [True: 68.2k, False: 0]
  ------------------
  643|  68.2k|      buffer[buffer_pos++] = static_cast<char>(*current);
  644|  68.2k|      significant_digits++;
  645|       |      // Will later check if it's an octal in the buffer.
  646|  68.2k|    } else {
  647|    400|      insignificant_digits++;  // Move the digit into the exponential part.
  648|    400|      nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
  ------------------
  |  Branch (648:31): [True: 195, False: 205]
  |  Branch (648:56): [True: 13, False: 192]
  ------------------
  649|    400|    }
  650|  68.6k|    octal = octal && *current < '8';
  ------------------
  |  Branch (650:13): [True: 6.29k, False: 62.3k]
  |  Branch (650:22): [True: 6.28k, False: 6]
  ------------------
  651|  68.6k|    if (Advance(&current, separator_, 10, end)) goto parsing_done;
  ------------------
  |  Branch (651:9): [True: 756, False: 67.8k]
  ------------------
  652|  68.6k|  }
  653|       |
  654|  1.49k|  if (significant_digits == 0) {
  ------------------
  |  Branch (654:7): [True: 274, False: 1.21k]
  ------------------
  655|    274|    octal = false;
  656|    274|  }
  657|       |
  658|  1.49k|  if (*current == '.') {
  ------------------
  |  Branch (658:7): [True: 403, False: 1.08k]
  ------------------
  659|    403|    if (octal && !allow_trailing_junk) return junk_string_value_;
  ------------------
  |  Branch (659:9): [True: 1, False: 402]
  |  Branch (659:18): [True: 0, False: 1]
  ------------------
  660|    403|    if (octal) goto parsing_done;
  ------------------
  |  Branch (660:9): [True: 1, False: 402]
  ------------------
  661|       |
  662|    402|    if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (662:9): [True: 5, False: 397]
  ------------------
  663|      5|      if (significant_digits == 0 && !leading_zero) {
  ------------------
  |  Branch (663:11): [True: 3, False: 2]
  |  Branch (663:38): [True: 2, False: 1]
  ------------------
  664|      2|        return junk_string_value_;
  665|      3|      } else {
  666|      3|        goto parsing_done;
  667|      3|      }
  668|      5|    }
  669|       |
  670|    397|    if (significant_digits == 0) {
  ------------------
  |  Branch (670:9): [True: 162, False: 235]
  ------------------
  671|       |      // octal = false;
  672|       |      // Integer part consists of 0 or is absent. Significant digits start after
  673|       |      // leading zeros (if any).
  674|  3.87M|      while (*current == '0') {
  ------------------
  |  Branch (674:14): [True: 3.87M, False: 149]
  ------------------
  675|  3.87M|        if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (675:13): [True: 13, False: 3.87M]
  ------------------
  676|     13|          *processed_characters_count = static_cast<int>(current - input);
  677|     13|          return SignedZero(sign);
  678|     13|        }
  679|       |        // Saturate to avoid underflow on a pathologically long zero run.
  680|  3.87M|        if (exponent > -(max_exponent / 2)) exponent--;  // Move this 0 into the exponent.
  ------------------
  |  Branch (680:13): [True: 3.87M, False: 0]
  ------------------
  681|  3.87M|      }
  682|    162|    }
  683|       |
  684|       |    // There is a fractional part.
  685|       |    // We don't emit a '.', but adjust the exponent instead.
  686|  81.9k|    while (*current >= '0' && *current <= '9') {
  ------------------
  |  Branch (686:12): [True: 81.9k, False: 34]
  |  Branch (686:31): [True: 81.8k, False: 86]
  ------------------
  687|  81.8k|      if (significant_digits < kMaxSignificantDigits) {
  ------------------
  |  Branch (687:11): [True: 64.4k, False: 17.3k]
  ------------------
  688|  64.4k|        DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  64.4k|    assert(condition)
  ------------------
  |  Branch (688:9): [True: 64.4k, False: 0]
  ------------------
  689|  64.4k|        buffer[buffer_pos++] = static_cast<char>(*current);
  690|  64.4k|        significant_digits++;
  691|  64.4k|        if (exponent > -(max_exponent / 2)) exponent--;
  ------------------
  |  Branch (691:13): [True: 64.4k, False: 0]
  ------------------
  692|  64.4k|      } else {
  693|       |        // Ignore insignificant digits in the fractional part.
  694|  17.3k|        nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
  ------------------
  |  Branch (694:33): [True: 194, False: 17.2k]
  |  Branch (694:58): [True: 14, False: 17.1k]
  ------------------
  695|  17.3k|      }
  696|  81.8k|      if (Advance(&current, separator_, 10, end)) goto parsing_done;
  ------------------
  |  Branch (696:11): [True: 264, False: 81.5k]
  ------------------
  697|  81.8k|    }
  698|    384|  }
  699|       |
  700|  1.20k|  if (!leading_zero && exponent == 0 && significant_digits == 0) {
  ------------------
  |  Branch (700:7): [True: 1.14k, False: 58]
  |  Branch (700:24): [True: 1.05k, False: 99]
  |  Branch (700:41): [True: 73, False: 977]
  ------------------
  701|       |    // If leading_zeros is true then the string contains zeros.
  702|       |    // If exponent < 0 then string was [+-]\.0*...
  703|       |    // If significant_digits != 0 the string is not equal to 0.
  704|       |    // Otherwise there are no digits in the string.
  705|     73|    return junk_string_value_;
  706|     73|  }
  707|       |
  708|       |  // Parse exponential part.
  709|  1.13k|  if (*current == 'e' || *current == 'E') {
  ------------------
  |  Branch (709:7): [True: 516, False: 618]
  |  Branch (709:26): [True: 517, False: 101]
  ------------------
  710|  1.03k|    if (octal && !allow_trailing_junk) return junk_string_value_;
  ------------------
  |  Branch (710:9): [True: 1, False: 1.03k]
  |  Branch (710:18): [True: 0, False: 1]
  ------------------
  711|  1.03k|    if (octal) goto parsing_done;
  ------------------
  |  Branch (711:9): [True: 1, False: 1.03k]
  ------------------
  712|  1.03k|    Iterator junk_begin = current;
  713|  1.03k|    ++current;
  714|  1.03k|    if (current == end) {
  ------------------
  |  Branch (714:9): [True: 3, False: 1.02k]
  ------------------
  715|      3|      if (allow_trailing_junk) {
  ------------------
  |  Branch (715:11): [True: 3, False: 0]
  ------------------
  716|      3|        current = junk_begin;
  717|      3|        goto parsing_done;
  718|      3|      } else {
  719|      0|        return junk_string_value_;
  720|      0|      }
  721|      3|    }
  722|  1.02k|    char exponen_sign = '+';
  723|  1.02k|    if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (723:9): [True: 2, False: 1.02k]
  |  Branch (723:28): [True: 382, False: 645]
  ------------------
  724|    384|      exponen_sign = static_cast<char>(*current);
  725|    384|      ++current;
  726|    384|      if (current == end) {
  ------------------
  |  Branch (726:11): [True: 2, False: 382]
  ------------------
  727|      2|        if (allow_trailing_junk) {
  ------------------
  |  Branch (727:13): [True: 2, False: 0]
  ------------------
  728|      2|          current = junk_begin;
  729|      2|          goto parsing_done;
  730|      2|        } else {
  731|      0|          return junk_string_value_;
  732|      0|        }
  733|      2|      }
  734|    384|    }
  735|       |
  736|  1.02k|    if (current == end || *current < '0' || *current > '9') {
  ------------------
  |  Branch (736:9): [True: 0, False: 1.02k]
  |  Branch (736:27): [True: 17, False: 1.01k]
  |  Branch (736:45): [True: 5, False: 1.00k]
  ------------------
  737|     22|      if (allow_trailing_junk) {
  ------------------
  |  Branch (737:11): [True: 22, False: 0]
  ------------------
  738|     22|        current = junk_begin;
  739|     22|        goto parsing_done;
  740|     22|      } else {
  741|      0|        return junk_string_value_;
  742|      0|      }
  743|     22|    }
  744|       |
  745|  1.00k|    DOUBLE_CONVERSION_ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
  ------------------
  |  |   47|  1.00k|    assert(condition)
  ------------------
  |  Branch (745:5): [True: 1.00k, False: 0]
  |  Branch (745:5): [True: 1.00k, False: 0]
  |  Branch (745:5): [True: 1.00k, False: 0]
  ------------------
  746|  1.00k|    int num = 0;
  747|  5.13k|    do {
  748|       |      // Check overflow.
  749|  5.13k|      int digit = *current - '0';
  750|  5.13k|      if (num >= max_exponent / 10
  ------------------
  |  Branch (750:11): [True: 1.10k, False: 4.03k]
  ------------------
  751|  1.10k|          && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
  ------------------
  |  Branch (751:16): [True: 7, False: 1.09k]
  |  Branch (751:44): [True: 5, False: 2]
  ------------------
  752|  1.10k|        num = max_exponent;
  753|  4.03k|      } else {
  754|  4.03k|        num = num * 10 + digit;
  755|  4.03k|      }
  756|  5.13k|      ++current;
  757|  5.13k|    } while (current != end && *current >= '0' && *current <= '9');
  ------------------
  |  Branch (757:14): [True: 4.14k, False: 989]
  |  Branch (757:32): [True: 4.13k, False: 12]
  |  Branch (757:51): [True: 4.13k, False: 4]
  ------------------
  758|       |
  759|  1.00k|    exponent += (exponen_sign == '-' ? -num : num);
  ------------------
  |  Branch (759:18): [True: 381, False: 624]
  ------------------
  760|  1.00k|  }
  761|       |
  762|  1.10k|  if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (762:9): [True: 1.10k, False: 0]
  |  Branch (762:34): [True: 0, False: 0]
  |  Branch (762:58): [True: 0, False: 0]
  ------------------
  763|      0|    return junk_string_value_;
  764|      0|  }
  765|  1.10k|  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (765:7): [True: 0, False: 1.10k]
  |  Branch (765:31): [True: 0, False: 0]
  ------------------
  766|      0|    return junk_string_value_;
  767|      0|  }
  768|  1.10k|  if (allow_trailing_spaces) {
  ------------------
  |  Branch (768:7): [True: 1.10k, False: 0]
  ------------------
  769|  1.10k|    AdvanceToNonspace(&current, end);
  770|  1.10k|  }
  771|       |
  772|  2.15k|  parsing_done:
  773|       |  // insignificant_digits counts integer digits dropped past the significand
  774|       |  // limit and is bounded only by the input length, so exponent + it can exceed
  775|       |  // int. Saturate: such a value is out of the double range regardless.
  776|  2.15k|  {
  777|  2.15k|    const int64_t combined =
  778|  2.15k|        static_cast<int64_t>(exponent) + insignificant_digits;
  779|  2.15k|    exponent = combined > max_exponent ? max_exponent
  ------------------
  |  Branch (779:16): [True: 0, False: 2.15k]
  ------------------
  780|  2.15k|                                       : static_cast<int>(combined);
  781|  2.15k|  }
  782|       |
  783|  2.15k|  if (octal) {
  ------------------
  |  Branch (783:7): [True: 217, False: 1.94k]
  ------------------
  784|    217|    double result;
  785|    217|    bool result_is_junk;
  786|    217|    char* start = buffer;
  787|    217|    result = RadixStringToIeee<3>(&start,
  788|    217|                                  buffer + buffer_pos,
  789|    217|                                  sign,
  790|    217|                                  separator_,
  791|    217|                                  false, // Don't parse as hex_float.
  792|    217|                                  allow_trailing_junk,
  793|    217|                                  allow_trailing_spaces,
  794|    217|                                  junk_string_value_,
  795|    217|                                  read_as_double,
  796|    217|                                  &result_is_junk);
  797|    217|    DOUBLE_CONVERSION_ASSERT(!result_is_junk);
  ------------------
  |  |   47|    217|    assert(condition)
  ------------------
  |  Branch (797:5): [True: 217, False: 0]
  ------------------
  798|    217|    *processed_characters_count = static_cast<int>(current - input);
  799|    217|    return result;
  800|    217|  }
  801|       |
  802|  1.94k|  if (nonzero_digit_dropped) {
  ------------------
  |  Branch (802:7): [True: 27, False: 1.91k]
  ------------------
  803|     27|    buffer[buffer_pos++] = '1';
  804|     27|    exponent--;
  805|     27|  }
  806|       |
  807|  1.94k|  DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  1.94k|    assert(condition)
  ------------------
  |  Branch (807:3): [True: 1.94k, False: 0]
  ------------------
  808|  1.94k|  buffer[buffer_pos] = '\0';
  809|       |
  810|       |  // Code above ensures there are no leading zeros and the buffer has fewer than
  811|       |  // kMaxSignificantDecimalDigits characters. Trim trailing zeros.
  812|  1.94k|  Vector<const char> chars(buffer, buffer_pos);
  813|  1.94k|  chars = TrimTrailingZeros(chars);
  814|  1.94k|  exponent += buffer_pos - chars.length();
  815|       |
  816|  1.94k|  double converted;
  817|  1.94k|  if (read_as_double) {
  ------------------
  |  Branch (817:7): [True: 1.94k, False: 0]
  ------------------
  818|  1.94k|    converted = StrtodTrimmed(chars, exponent);
  819|  1.94k|  } else {
  820|      0|    converted = StrtofTrimmed(chars, exponent);
  821|      0|  }
  822|  1.94k|  *processed_characters_count = static_cast<int>(current - input);
  823|  1.94k|  return sign? -converted: converted;
  ------------------
  |  Branch (823:10): [True: 1, False: 1.94k]
  ------------------
  824|  1.94k|}
string-to-double.cc:_ZN17double_conversionL17AdvanceToNonspaceIPKcEEbPT_S3_:
  156|  4.72k|static inline bool AdvanceToNonspace(Iterator* current, Iterator end) {
  157|  6.57k|  while (*current != end) {
  ------------------
  |  Branch (157:10): [True: 5.13k, False: 1.44k]
  ------------------
  158|  5.13k|    if (!isWhitespace(**current)) return true;
  ------------------
  |  Branch (158:9): [True: 3.28k, False: 1.84k]
  ------------------
  159|  1.84k|    ++*current;
  160|  1.84k|  }
  161|  1.44k|  return false;
  162|  4.72k|}
string-to-double.cc:_ZN17double_conversionL12isWhitespaceEi:
  140|  5.13k|static bool isWhitespace(int x) {
  141|  5.13k|  if (x < 128) {
  ------------------
  |  Branch (141:7): [True: 5.13k, False: 0]
  ------------------
  142|  30.8k|    for (int i = 0; i < kWhitespaceTable7Length; i++) {
  ------------------
  |  Branch (142:21): [True: 27.5k, False: 3.28k]
  ------------------
  143|  27.5k|      if (kWhitespaceTable7[i] == x) return true;
  ------------------
  |  Branch (143:11): [True: 1.84k, False: 25.6k]
  ------------------
  144|  27.5k|    }
  145|  5.13k|  } else {
  146|      0|    for (int i = 0; i < kWhitespaceTable16Length; i++) {
  ------------------
  |  Branch (146:21): [True: 0, False: 0]
  ------------------
  147|      0|      if (kWhitespaceTable16[i] == x) return true;
  ------------------
  |  Branch (147:11): [True: 0, False: 0]
  ------------------
  148|      0|    }
  149|      0|  }
  150|  3.28k|  return false;
  151|  5.13k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_121ConsumeFirstCharacterIcEEbT_PKcb:
  112|  5.80k|                                         bool case_insensitivity) {
  113|  5.80k|  const uint32_t c = CodeUnit(ch);
  114|  5.80k|  const uint32_t first = CodeUnit(str[0]);
  115|  5.80k|  return case_insensitivity ? ToLower(c) == ToLower(first) : c == first;
  ------------------
  |  Branch (115:10): [True: 5.80k, False: 0]
  ------------------
  116|  5.80k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_18CodeUnitEc:
   57|  11.7k|inline uint32_t CodeUnit(char ch) {
   58|  11.7k|  return static_cast<unsigned char>(ch);
   59|  11.7k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_17ToLowerEj:
   65|  11.7k|inline uint32_t ToLower(uint32_t ch) {
   66|  11.7k|  if (ch > 0x7F) return ch;
  ------------------
  |  Branch (66:7): [True: 54, False: 11.6k]
  ------------------
   67|  11.6k|  static const std::ctype<char>& cType =
   68|  11.6k|      std::use_facet<std::ctype<char> >(std::locale::classic());
   69|  11.6k|  return static_cast<unsigned char>(cType.tolower(static_cast<char>(ch)));
   70|  11.7k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_116ConsumeSubStringIPKcEEbPT_S4_S3_b:
  100|     20|                             bool allow_case_insensitivity) {
  101|     20|  if (allow_case_insensitivity) {
  ------------------
  |  Branch (101:7): [True: 20, False: 0]
  ------------------
  102|     20|    return ConsumeSubStringImpl(current, end, substring, ToLower);
  103|     20|  } else {
  104|      0|    return ConsumeSubStringImpl(current, end, substring, Pass);
  105|      0|  }
  106|     20|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_120ConsumeSubStringImplIPKcPFjjEEEbPT_S6_S3_T0_:
   80|     20|                                        Converter converter) {
   81|     20|  DOUBLE_CONVERSION_ASSERT(
  ------------------
  |  |   47|     20|    assert(condition)
  ------------------
  |  Branch (81:3): [True: 20, False: 0]
  ------------------
   82|     20|      converter(CodeUnit(**current)) == converter(CodeUnit(*substring)));
   83|     32|  for (substring++; *substring != '\0'; substring++) {
  ------------------
  |  Branch (83:21): [True: 28, False: 4]
  ------------------
   84|     28|    ++*current;
   85|     28|    if (*current == end ||
  ------------------
  |  Branch (85:9): [True: 6, False: 22]
  ------------------
   86|     22|        converter(CodeUnit(**current)) != converter(CodeUnit(*substring))) {
  ------------------
  |  Branch (86:9): [True: 10, False: 12]
  ------------------
   87|     16|      return false;
   88|     16|    }
   89|     28|  }
   90|      4|  ++*current;
   91|      4|  return true;
   92|     20|}
string-to-double.cc:_ZN17double_conversionL7AdvanceIPKcEEbPT_tiRS3_:
  207|  9.55M|static bool Advance (Iterator* it, uc16 separator, int base, Iterator& end) {
  208|  9.55M|  if (separator == StringToDoubleConverter::kNoSeparator) {
  ------------------
  |  Branch (208:7): [True: 9.55M, False: 0]
  ------------------
  209|  9.55M|    ++(*it);
  210|  9.55M|    return *it == end;
  211|  9.55M|  }
  212|      0|  if (!isDigit(**it, base)) {
  ------------------
  |  Branch (212:7): [True: 0, False: 0]
  ------------------
  213|      0|    ++(*it);
  214|      0|    return *it == end;
  215|      0|  }
  216|      0|  ++(*it);
  217|      0|  if (*it == end) return true;
  ------------------
  |  Branch (217:7): [True: 0, False: 0]
  ------------------
  218|      0|  if (*it + 1 == end) return false;
  ------------------
  |  Branch (218:7): [True: 0, False: 0]
  ------------------
  219|      0|  if (**it == separator && isDigit(*(*it + 1), base)) {
  ------------------
  |  Branch (219:7): [True: 0, False: 0]
  |  Branch (219:28): [True: 0, False: 0]
  ------------------
  220|      0|    ++(*it);
  221|      0|  }
  222|      0|  return *it == end;
  223|      0|}
string-to-double.cc:_ZN17double_conversionL10SignedZeroEb:
  172|     33|static double SignedZero(bool sign) {
  173|     33|  return sign ? -0.0 : 0.0;
  ------------------
  |  Branch (173:10): [True: 0, False: 33]
  ------------------
  174|     33|}
string-to-double.cc:_ZN17double_conversionL16IsHexFloatStringIPKcEEbT_S3_tbb:
  237|    842|                             bool allow_trailing_spaces) {
  238|    842|  DOUBLE_CONVERSION_ASSERT(start != end);
  ------------------
  |  |   47|    842|    assert(condition)
  ------------------
  |  Branch (238:3): [True: 842, False: 0]
  ------------------
  239|       |
  240|    842|  Iterator current = start;
  241|       |
  242|    842|  bool saw_digit = false;
  243|  1.05M|  while (isDigit(*current, 16)) {
  ------------------
  |  Branch (243:10): [True: 1.05M, False: 634]
  ------------------
  244|  1.05M|    saw_digit = true;
  245|  1.05M|    if (Advance(&current, separator, 16, end)) return false;
  ------------------
  |  Branch (245:9): [True: 208, False: 1.05M]
  ------------------
  246|  1.05M|  }
  247|    634|  if (*current == '.') {
  ------------------
  |  Branch (247:7): [True: 134, False: 500]
  ------------------
  248|    134|    if (Advance(&current, separator, 16, end)) return false;
  ------------------
  |  Branch (248:9): [True: 3, False: 131]
  ------------------
  249|  2.30M|    while (isDigit(*current, 16)) {
  ------------------
  |  Branch (249:12): [True: 2.30M, False: 113]
  ------------------
  250|  2.30M|      saw_digit = true;
  251|  2.30M|      if (Advance(&current, separator, 16, end)) return false;
  ------------------
  |  Branch (251:11): [True: 18, False: 2.30M]
  ------------------
  252|  2.30M|    }
  253|    131|  }
  254|    613|  if (!saw_digit) return false;
  ------------------
  |  Branch (254:7): [True: 60, False: 553]
  ------------------
  255|    553|  if (*current != 'p' && *current != 'P') return false;
  ------------------
  |  Branch (255:7): [True: 258, False: 295]
  |  Branch (255:26): [True: 100, False: 158]
  ------------------
  256|       |  // The separator is only allowed between significand digits, not in the
  257|       |  // exponent, so advance through the exponent with no separator.
  258|    453|  const uc16 kNoSeparator = StringToDoubleConverter::kNoSeparator;
  259|    453|  if (Advance(&current, kNoSeparator, 16, end)) return false;
  ------------------
  |  Branch (259:7): [True: 2, False: 451]
  ------------------
  260|    451|  if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (260:7): [True: 4, False: 447]
  |  Branch (260:26): [True: 65, False: 382]
  ------------------
  261|     69|    if (Advance(&current, kNoSeparator, 16, end)) return false;
  ------------------
  |  Branch (261:9): [True: 2, False: 67]
  ------------------
  262|     69|  }
  263|    449|  if (!isDigit(*current, 10)) return false;
  ------------------
  |  Branch (263:7): [True: 23, False: 426]
  ------------------
  264|    426|  if (Advance(&current, kNoSeparator, 16, end)) return true;
  ------------------
  |  Branch (264:7): [True: 222, False: 204]
  ------------------
  265|  2.01k|  while (isDigit(*current, 10)) {
  ------------------
  |  Branch (265:10): [True: 1.97k, False: 40]
  ------------------
  266|  1.97k|    if (Advance(&current, kNoSeparator, 16, end)) return true;
  ------------------
  |  Branch (266:9): [True: 164, False: 1.80k]
  ------------------
  267|  1.97k|  }
  268|       |  // Trailing whitespace is junk unless ALLOW_TRAILING_SPACES is set, as it is
  269|       |  // for decimal numbers.
  270|     40|  if (allow_trailing_junk) return true;
  ------------------
  |  Branch (270:7): [True: 40, False: 0]
  ------------------
  271|      0|  return allow_trailing_spaces && !AdvanceToNonspace(&current, end);
  ------------------
  |  Branch (271:10): [True: 0, False: 0]
  |  Branch (271:35): [True: 0, False: 0]
  ------------------
  272|     40|}
string-to-double.cc:_ZN17double_conversionL7isDigitEii:
  165|  4.41M|static bool isDigit(int x, int radix) {
  166|  4.41M|  return (x >= '0' && x <= '9' && x < '0' + radix)
  ------------------
  |  Branch (166:11): [True: 4.41M, False: 356]
  |  Branch (166:23): [True: 4.37M, False: 39.3k]
  |  Branch (166:35): [True: 4.37M, False: 0]
  ------------------
  167|  39.7k|      || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
  ------------------
  |  Branch (167:11): [True: 39.6k, False: 63]
  |  Branch (167:25): [True: 35.8k, False: 3.79k]
  |  Branch (167:37): [True: 35.5k, False: 342]
  ------------------
  168|  4.19k|      || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
  ------------------
  |  Branch (168:11): [True: 4.13k, False: 63]
  |  Branch (168:25): [True: 3.79k, False: 337]
  |  Branch (168:37): [True: 3.23k, False: 558]
  ------------------
  169|  4.41M|}
string-to-double.cc:_ZN17double_conversionL17RadixStringToIeeeILi4EPKcEEdPT0_S3_btbbbdbPb:
  289|    544|                                bool* result_is_junk) {
  290|    544|  DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    544|    assert(condition)
  ------------------
  |  Branch (290:3): [True: 544, False: 0]
  ------------------
  291|    544|  DOUBLE_CONVERSION_ASSERT(!parse_as_hex_float ||
  ------------------
  |  |   47|    544|    assert(condition)
  ------------------
  |  Branch (291:3): [True: 331, False: 213]
  |  Branch (291:3): [True: 213, False: 0]
  |  Branch (291:3): [True: 544, False: 0]
  ------------------
  292|    544|      IsHexFloatString(*current, end, separator, allow_trailing_junk,
  293|    544|                       allow_trailing_spaces));
  294|       |
  295|    544|  const int kDoubleSize = Double::kSignificandSize;
  296|    544|  const int kSingleSize = Single::kSignificandSize;
  297|       |  // A hex-float is formed here as a double and rounded to float by the caller
  298|       |  // (StringToFloat casts the result). Rounding the significand to single
  299|       |  // precision here would double-round both subnormal floats and floats whose
  300|       |  // exact significand exceeds 53 bits, so keep the full double significand and
  301|       |  // round it to odd, which makes that final single-precision cast correct.
  302|    544|  const bool round_hex_float_to_single = parse_as_hex_float && !read_as_double;
  ------------------
  |  Branch (302:42): [True: 213, False: 331]
  |  Branch (302:64): [True: 0, False: 213]
  ------------------
  303|    544|  const int kSignificandSize =
  304|    544|      (read_as_double || parse_as_hex_float) ? kDoubleSize : kSingleSize;
  ------------------
  |  Branch (304:8): [True: 544, False: 0]
  |  Branch (304:26): [True: 0, False: 0]
  ------------------
  305|       |
  306|    544|  *result_is_junk = true;
  307|       |
  308|    544|  int64_t number = 0;
  309|    544|  int exponent = 0;
  310|    544|  const int radix = (1 << radix_log_2);
  311|       |  // Whether we have encountered a '.' and are parsing the decimal digits.
  312|       |  // Only relevant if parse_as_hex_float is true.
  313|    544|  bool post_decimal = false;
  314|       |
  315|       |  // Skip leading 0s.
  316|    983|  while (**current == '0') {
  ------------------
  |  Branch (316:10): [True: 447, False: 536]
  ------------------
  317|    447|    if (Advance(current, separator, radix, end)) {
  ------------------
  |  Branch (317:9): [True: 8, False: 439]
  ------------------
  318|      8|      *result_is_junk = false;
  319|      8|      return SignedZero(sign);
  320|      8|    }
  321|    447|  }
  322|       |
  323|  1.10M|  while (true) {
  ------------------
  |  Branch (323:10): [True: 1.10M, Folded]
  ------------------
  324|  1.10M|    int digit;
  325|  1.10M|    if (IsDecimalDigitForRadix(**current, radix)) {
  ------------------
  |  Branch (325:9): [True: 1.10M, False: 2.36k]
  ------------------
  326|  1.10M|      digit = static_cast<char>(**current) - '0';
  327|  1.10M|      if (post_decimal) exponent -= radix_log_2;
  ------------------
  |  Branch (327:11): [True: 1.10M, False: 1.06k]
  ------------------
  328|  1.10M|    } else if (IsCharacterDigitForRadix(**current, radix, 'a')) {
  ------------------
  |  Branch (328:16): [True: 998, False: 1.36k]
  ------------------
  329|    998|      digit = static_cast<char>(**current) - 'a' + 10;
  330|    998|      if (post_decimal) exponent -= radix_log_2;
  ------------------
  |  Branch (330:11): [True: 63, False: 935]
  ------------------
  331|  1.36k|    } else if (IsCharacterDigitForRadix(**current, radix, 'A')) {
  ------------------
  |  Branch (331:16): [True: 1.05k, False: 313]
  ------------------
  332|  1.05k|      digit = static_cast<char>(**current) - 'A' + 10;
  333|  1.05k|      if (post_decimal) exponent -= radix_log_2;
  ------------------
  |  Branch (333:11): [True: 72, False: 980]
  ------------------
  334|  1.05k|    } else if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (334:16): [True: 219, False: 94]
  |  Branch (334:38): [True: 40, False: 179]
  ------------------
  335|     40|      post_decimal = true;
  336|     40|      Advance(current, separator, radix, end);
  337|     40|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|     40|    assert(condition)
  ------------------
  |  Branch (337:7): [True: 40, False: 0]
  ------------------
  338|     40|      continue;
  339|    273|    } else if (parse_as_hex_float && (**current == 'p' || **current == 'P')) {
  ------------------
  |  Branch (339:16): [True: 179, False: 94]
  |  Branch (339:39): [True: 121, False: 58]
  |  Branch (339:59): [True: 58, False: 0]
  ------------------
  340|    179|      break;
  341|    179|    } else {
  342|       |      // Trailing whitespace is junk unless ALLOW_TRAILING_SPACES is set, as it
  343|       |      // is for decimal numbers.
  344|     94|      if (allow_trailing_junk ||
  ------------------
  |  Branch (344:11): [True: 94, False: 0]
  ------------------
  345|     94|          (allow_trailing_spaces && !AdvanceToNonspace(current, end))) {
  ------------------
  |  Branch (345:12): [True: 0, False: 0]
  |  Branch (345:37): [True: 0, False: 0]
  ------------------
  346|     94|        break;
  347|     94|      } else {
  348|      0|        return junk_string_value;
  349|      0|      }
  350|     94|    }
  351|       |
  352|  1.10M|    number = number * radix + digit;
  353|  1.10M|    int overflow = static_cast<int>(number >> kSignificandSize);
  354|  1.10M|    if (overflow != 0) {
  ------------------
  |  Branch (354:9): [True: 139, False: 1.10M]
  ------------------
  355|       |      // Overflow occurred. Need to determine which direction to round the
  356|       |      // result.
  357|    139|      int overflow_bits_count = 1;
  358|    401|      while (overflow > 1) {
  ------------------
  |  Branch (358:14): [True: 262, False: 139]
  ------------------
  359|    262|        overflow_bits_count++;
  360|    262|        overflow >>= 1;
  361|    262|      }
  362|       |
  363|    139|      int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
  364|    139|      int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
  365|    139|      number >>= overflow_bits_count;
  366|    139|      exponent += overflow_bits_count;
  367|       |
  368|    139|      bool zero_tail = true;
  369|  1.05M|      for (;;) {
  370|  1.05M|        if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (370:13): [True: 76, False: 1.05M]
  ------------------
  371|  1.05M|        if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (371:13): [True: 771, False: 1.05M]
  |  Branch (371:35): [True: 2, False: 769]
  ------------------
  372|       |          // Just run over the '.'. We are just trying to see whether there is
  373|       |          // a non-zero digit somewhere.
  374|      2|          Advance(current, separator, radix, end);
  375|      2|          DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      2|    assert(condition)
  ------------------
  |  Branch (375:11): [True: 2, False: 0]
  ------------------
  376|      2|          post_decimal = true;
  377|      2|        }
  378|  1.05M|        if (!isDigit(**current, radix)) break;
  ------------------
  |  Branch (378:13): [True: 63, False: 1.05M]
  ------------------
  379|  1.05M|        zero_tail = zero_tail && **current == '0';
  ------------------
  |  Branch (379:21): [True: 68.8k, False: 983k]
  |  Branch (379:34): [True: 68.8k, False: 83]
  ------------------
  380|  1.05M|        if (!post_decimal) {
  ------------------
  |  Branch (380:13): [True: 1.05M, False: 397]
  ------------------
  381|  1.05M|          if (exponent <= INT_MAX - radix_log_2) {
  ------------------
  |  Branch (381:15): [True: 1.05M, False: 0]
  ------------------
  382|  1.05M|            exponent += radix_log_2;
  383|  1.05M|          } else {
  384|      0|            exponent = INT_MAX;
  385|      0|          }
  386|  1.05M|        }
  387|  1.05M|      }
  388|       |
  389|    139|      if (!parse_as_hex_float && !allow_trailing_junk) {
  ------------------
  |  Branch (389:11): [True: 105, False: 34]
  |  Branch (389:34): [True: 0, False: 105]
  ------------------
  390|      0|        if (allow_trailing_spaces ? AdvanceToNonspace(current, end)
  ------------------
  |  Branch (390:13): [True: 0, False: 0]
  |  Branch (390:13): [True: 0, False: 0]
  ------------------
  391|      0|                                  : *current != end) {
  392|      0|          return junk_string_value;
  393|      0|        }
  394|      0|      }
  395|       |
  396|    139|      if (round_hex_float_to_single) {
  ------------------
  |  Branch (396:11): [True: 0, False: 139]
  ------------------
  397|       |        // Round the significand to odd: set the lowest kept bit whenever any
  398|       |        // bit was dropped. The caller rounds this double to float; rounding to
  399|       |        // nearest here would double-round, but round-to-odd leaves that final
  400|       |        // single rounding correct for normal and subnormal results alike.
  401|      0|        if (dropped_bits != 0 || !zero_tail) {
  ------------------
  |  Branch (401:13): [True: 0, False: 0]
  |  Branch (401:34): [True: 0, False: 0]
  ------------------
  402|      0|          number |= 1;
  403|      0|        }
  404|    139|      } else {
  405|    139|        int middle_value = (1 << (overflow_bits_count - 1));
  406|    139|        if (dropped_bits > middle_value) {
  ------------------
  |  Branch (406:13): [True: 45, False: 94]
  ------------------
  407|     45|          number++;  // Rounding up.
  408|     94|        } else if (dropped_bits == middle_value) {
  ------------------
  |  Branch (408:20): [True: 20, False: 74]
  ------------------
  409|       |          // Rounding to even to consistency with decimals: half-way case rounds
  410|       |          // up if significant part is odd and down otherwise.
  411|     20|          if ((number & 1) != 0 || !zero_tail) {
  ------------------
  |  Branch (411:15): [True: 11, False: 9]
  |  Branch (411:36): [True: 5, False: 4]
  ------------------
  412|     16|            number++;  // Rounding up.
  413|     16|          }
  414|     20|        }
  415|       |
  416|       |        // Rounding up may cause overflow.
  417|    139|        if ((number & ((int64_t)1 << kSignificandSize)) != 0) {
  ------------------
  |  Branch (417:13): [True: 8, False: 131]
  ------------------
  418|      8|          exponent++;
  419|      8|          number >>= 1;
  420|      8|        }
  421|    139|      }
  422|    139|      break;
  423|    139|    }
  424|  1.10M|    if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (424:9): [True: 124, False: 1.10M]
  ------------------
  425|  1.10M|  }
  426|       |
  427|    536|  DOUBLE_CONVERSION_ASSERT(number < ((int64_t)1 << kSignificandSize));
  ------------------
  |  |   47|    536|    assert(condition)
  ------------------
  |  Branch (427:3): [True: 536, False: 0]
  ------------------
  428|    536|  DOUBLE_CONVERSION_ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
  ------------------
  |  |   47|    536|    assert(condition)
  ------------------
  |  Branch (428:3): [True: 536, False: 0]
  ------------------
  429|       |
  430|    536|  *result_is_junk = false;
  431|       |
  432|    536|  if (parse_as_hex_float) {
  ------------------
  |  Branch (432:7): [True: 213, False: 323]
  ------------------
  433|    213|    DOUBLE_CONVERSION_ASSERT(**current == 'p' || **current == 'P');
  ------------------
  |  |   47|    213|    assert(condition)
  ------------------
  |  Branch (433:5): [True: 140, False: 73]
  |  Branch (433:5): [True: 73, False: 0]
  |  Branch (433:5): [True: 213, False: 0]
  ------------------
  434|       |    // The separator is only allowed between significand digits, not in the
  435|       |    // exponent, so advance through the exponent with no separator. This must
  436|       |    // match IsHexFloatString, which validated the string the same way.
  437|    213|    const uc16 kNoSeparator = StringToDoubleConverter::kNoSeparator;
  438|    213|    Advance(current, kNoSeparator, radix, end);
  439|    213|    DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    213|    assert(condition)
  ------------------
  |  Branch (439:5): [True: 213, False: 0]
  ------------------
  440|    213|    bool is_negative = false;
  441|    213|    if (**current == '+') {
  ------------------
  |  Branch (441:9): [True: 1, False: 212]
  ------------------
  442|      1|      Advance(current, kNoSeparator, radix, end);
  443|      1|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      1|    assert(condition)
  ------------------
  |  Branch (443:7): [True: 1, False: 0]
  ------------------
  444|    212|    } else if (**current == '-') {
  ------------------
  |  Branch (444:16): [True: 32, False: 180]
  ------------------
  445|     32|      is_negative = true;
  446|     32|      Advance(current, kNoSeparator, radix, end);
  447|     32|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|     32|    assert(condition)
  ------------------
  |  Branch (447:7): [True: 32, False: 0]
  ------------------
  448|     32|    }
  449|    213|    int written_exponent = 0;
  450|  1.21k|    while (IsDecimalDigitForRadix(**current, 10)) {
  ------------------
  |  Branch (450:12): [True: 1.19k, False: 20]
  ------------------
  451|       |      // No need to read exponents if they are too big. That could potentially overflow
  452|       |      // the `written_exponent` variable.
  453|  1.19k|      if (abs(written_exponent) <= 100 * Double::kMaxExponent) {
  ------------------
  |  Branch (453:11): [True: 883, False: 315]
  ------------------
  454|    883|        written_exponent = 10 * written_exponent + **current - '0';
  455|    883|      }
  456|  1.19k|      if (Advance(current, kNoSeparator, radix, end)) break;
  ------------------
  |  Branch (456:11): [True: 193, False: 1.00k]
  ------------------
  457|  1.19k|    }
  458|    213|    if (is_negative) written_exponent = -written_exponent;
  ------------------
  |  Branch (458:9): [True: 32, False: 181]
  ------------------
  459|    213|    exponent += written_exponent;
  460|    213|  }
  461|       |
  462|    536|  if (exponent == 0 || number == 0) {
  ------------------
  |  Branch (462:7): [True: 228, False: 308]
  |  Branch (462:24): [True: 33, False: 275]
  ------------------
  463|    261|    if (sign) {
  ------------------
  |  Branch (463:9): [True: 55, False: 206]
  ------------------
  464|     55|      if (number == 0) return -0.0;
  ------------------
  |  Branch (464:11): [True: 1, False: 54]
  ------------------
  465|     54|      number = -number;
  466|     54|    }
  467|    260|    return static_cast<double>(number);
  468|    261|  }
  469|       |
  470|    275|  DOUBLE_CONVERSION_ASSERT(number != 0);
  ------------------
  |  |   47|    275|    assert(condition)
  ------------------
  |  Branch (470:3): [True: 275, False: 0]
  ------------------
  471|       |  // number is an exact integer below 2^kSignificandSize, so number * 2^exponent
  472|       |  // can be formed directly. Double(DiyFp(number, exponent)) would instead assume
  473|       |  // a normalized significand: a hex-float like "0x1p1000" or "0x2p-1075" reaches
  474|       |  // here with a small number and a large exponent, which DiyFpToUint64 then reads
  475|       |  // as an overflow (infinity) or underflow (zero) rather than the finite result.
  476|    275|  double result = ldexp(static_cast<double>(number), exponent);
  477|    275|  return sign ? -result : result;
  ------------------
  |  Branch (477:10): [True: 1, False: 274]
  ------------------
  478|    275|}
string-to-double.cc:_ZN17double_conversionL22IsDecimalDigitForRadixEii:
  190|  1.11M|static bool inline IsDecimalDigitForRadix(int c, int radix) {
  191|  1.11M|  return '0' <= c && c <= '9' && (c - '0') < radix;
  ------------------
  |  Branch (191:10): [True: 1.11M, False: 104]
  |  Branch (191:22): [True: 1.11M, False: 2.27k]
  |  Branch (191:34): [True: 1.11M, False: 0]
  ------------------
  192|  1.11M|}
string-to-double.cc:_ZN17double_conversionL24IsCharacterDigitForRadixEiic:
  201|  3.72k|static bool IsCharacterDigitForRadix(int c, int radix, char a_character) {
  202|  3.72k|  return radix > 10 && c >= a_character && c < a_character + radix - 10;
  ------------------
  |  Branch (202:10): [True: 3.72k, False: 0]
  |  Branch (202:24): [True: 2.41k, False: 1.31k]
  |  Branch (202:44): [True: 2.05k, False: 362]
  ------------------
  203|  3.72k|}
string-to-double.cc:_ZN17double_conversionL17RadixStringToIeeeILi3EPcEEdPT0_S2_btbbbdbPb:
  289|    217|                                bool* result_is_junk) {
  290|    217|  DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    217|    assert(condition)
  ------------------
  |  Branch (290:3): [True: 217, False: 0]
  ------------------
  291|    217|  DOUBLE_CONVERSION_ASSERT(!parse_as_hex_float ||
  ------------------
  |  |   47|    217|    assert(condition)
  ------------------
  |  Branch (291:3): [True: 217, False: 0]
  |  Branch (291:3): [True: 0, False: 0]
  |  Branch (291:3): [True: 217, False: 0]
  ------------------
  292|    217|      IsHexFloatString(*current, end, separator, allow_trailing_junk,
  293|    217|                       allow_trailing_spaces));
  294|       |
  295|    217|  const int kDoubleSize = Double::kSignificandSize;
  296|    217|  const int kSingleSize = Single::kSignificandSize;
  297|       |  // A hex-float is formed here as a double and rounded to float by the caller
  298|       |  // (StringToFloat casts the result). Rounding the significand to single
  299|       |  // precision here would double-round both subnormal floats and floats whose
  300|       |  // exact significand exceeds 53 bits, so keep the full double significand and
  301|       |  // round it to odd, which makes that final single-precision cast correct.
  302|    217|  const bool round_hex_float_to_single = parse_as_hex_float && !read_as_double;
  ------------------
  |  Branch (302:42): [True: 0, False: 217]
  |  Branch (302:64): [True: 0, False: 0]
  ------------------
  303|    217|  const int kSignificandSize =
  304|    217|      (read_as_double || parse_as_hex_float) ? kDoubleSize : kSingleSize;
  ------------------
  |  Branch (304:8): [True: 217, False: 0]
  |  Branch (304:26): [True: 0, False: 0]
  ------------------
  305|       |
  306|    217|  *result_is_junk = true;
  307|       |
  308|    217|  int64_t number = 0;
  309|    217|  int exponent = 0;
  310|    217|  const int radix = (1 << radix_log_2);
  311|       |  // Whether we have encountered a '.' and are parsing the decimal digits.
  312|       |  // Only relevant if parse_as_hex_float is true.
  313|    217|  bool post_decimal = false;
  314|       |
  315|       |  // Skip leading 0s.
  316|    217|  while (**current == '0') {
  ------------------
  |  Branch (316:10): [True: 0, False: 217]
  ------------------
  317|      0|    if (Advance(current, separator, radix, end)) {
  ------------------
  |  Branch (317:9): [True: 0, False: 0]
  ------------------
  318|      0|      *result_is_junk = false;
  319|      0|      return SignedZero(sign);
  320|      0|    }
  321|      0|  }
  322|       |
  323|  2.87k|  while (true) {
  ------------------
  |  Branch (323:10): [True: 2.87k, Folded]
  ------------------
  324|  2.87k|    int digit;
  325|  2.87k|    if (IsDecimalDigitForRadix(**current, radix)) {
  ------------------
  |  Branch (325:9): [True: 2.87k, False: 0]
  ------------------
  326|  2.87k|      digit = static_cast<char>(**current) - '0';
  327|  2.87k|      if (post_decimal) exponent -= radix_log_2;
  ------------------
  |  Branch (327:11): [True: 0, False: 2.87k]
  ------------------
  328|  2.87k|    } else if (IsCharacterDigitForRadix(**current, radix, 'a')) {
  ------------------
  |  Branch (328:16): [True: 0, False: 0]
  ------------------
  329|      0|      digit = static_cast<char>(**current) - 'a' + 10;
  330|      0|      if (post_decimal) exponent -= radix_log_2;
  ------------------
  |  Branch (330:11): [True: 0, False: 0]
  ------------------
  331|      0|    } else if (IsCharacterDigitForRadix(**current, radix, 'A')) {
  ------------------
  |  Branch (331:16): [True: 0, False: 0]
  ------------------
  332|      0|      digit = static_cast<char>(**current) - 'A' + 10;
  333|      0|      if (post_decimal) exponent -= radix_log_2;
  ------------------
  |  Branch (333:11): [True: 0, False: 0]
  ------------------
  334|      0|    } else if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (334:16): [True: 0, False: 0]
  |  Branch (334:38): [True: 0, False: 0]
  ------------------
  335|      0|      post_decimal = true;
  336|      0|      Advance(current, separator, radix, end);
  337|      0|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (337:7): [True: 0, False: 0]
  ------------------
  338|      0|      continue;
  339|      0|    } else if (parse_as_hex_float && (**current == 'p' || **current == 'P')) {
  ------------------
  |  Branch (339:16): [True: 0, False: 0]
  |  Branch (339:39): [True: 0, False: 0]
  |  Branch (339:59): [True: 0, False: 0]
  ------------------
  340|      0|      break;
  341|      0|    } else {
  342|       |      // Trailing whitespace is junk unless ALLOW_TRAILING_SPACES is set, as it
  343|       |      // is for decimal numbers.
  344|      0|      if (allow_trailing_junk ||
  ------------------
  |  Branch (344:11): [True: 0, False: 0]
  ------------------
  345|      0|          (allow_trailing_spaces && !AdvanceToNonspace(current, end))) {
  ------------------
  |  Branch (345:12): [True: 0, False: 0]
  |  Branch (345:37): [True: 0, False: 0]
  ------------------
  346|      0|        break;
  347|      0|      } else {
  348|      0|        return junk_string_value;
  349|      0|      }
  350|      0|    }
  351|       |
  352|  2.87k|    number = number * radix + digit;
  353|  2.87k|    int overflow = static_cast<int>(number >> kSignificandSize);
  354|  2.87k|    if (overflow != 0) {
  ------------------
  |  Branch (354:9): [True: 103, False: 2.77k]
  ------------------
  355|       |      // Overflow occurred. Need to determine which direction to round the
  356|       |      // result.
  357|    103|      int overflow_bits_count = 1;
  358|    131|      while (overflow > 1) {
  ------------------
  |  Branch (358:14): [True: 28, False: 103]
  ------------------
  359|     28|        overflow_bits_count++;
  360|     28|        overflow >>= 1;
  361|     28|      }
  362|       |
  363|    103|      int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
  364|    103|      int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
  365|    103|      number >>= overflow_bits_count;
  366|    103|      exponent += overflow_bits_count;
  367|       |
  368|    103|      bool zero_tail = true;
  369|  3.51k|      for (;;) {
  370|  3.51k|        if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (370:13): [True: 103, False: 3.41k]
  ------------------
  371|  3.41k|        if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (371:13): [True: 0, False: 3.41k]
  |  Branch (371:35): [True: 0, False: 0]
  ------------------
  372|       |          // Just run over the '.'. We are just trying to see whether there is
  373|       |          // a non-zero digit somewhere.
  374|      0|          Advance(current, separator, radix, end);
  375|      0|          DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (375:11): [True: 0, False: 0]
  ------------------
  376|      0|          post_decimal = true;
  377|      0|        }
  378|  3.41k|        if (!isDigit(**current, radix)) break;
  ------------------
  |  Branch (378:13): [True: 0, False: 3.41k]
  ------------------
  379|  3.41k|        zero_tail = zero_tail && **current == '0';
  ------------------
  |  Branch (379:21): [True: 505, False: 2.90k]
  |  Branch (379:34): [True: 469, False: 36]
  ------------------
  380|  3.41k|        if (!post_decimal) {
  ------------------
  |  Branch (380:13): [True: 3.41k, False: 0]
  ------------------
  381|  3.41k|          if (exponent <= INT_MAX - radix_log_2) {
  ------------------
  |  Branch (381:15): [True: 3.41k, False: 0]
  ------------------
  382|  3.41k|            exponent += radix_log_2;
  383|  3.41k|          } else {
  384|      0|            exponent = INT_MAX;
  385|      0|          }
  386|  3.41k|        }
  387|  3.41k|      }
  388|       |
  389|    103|      if (!parse_as_hex_float && !allow_trailing_junk) {
  ------------------
  |  Branch (389:11): [True: 103, False: 0]
  |  Branch (389:34): [True: 0, False: 103]
  ------------------
  390|      0|        if (allow_trailing_spaces ? AdvanceToNonspace(current, end)
  ------------------
  |  Branch (390:13): [True: 0, False: 0]
  |  Branch (390:13): [True: 0, False: 0]
  ------------------
  391|      0|                                  : *current != end) {
  392|      0|          return junk_string_value;
  393|      0|        }
  394|      0|      }
  395|       |
  396|    103|      if (round_hex_float_to_single) {
  ------------------
  |  Branch (396:11): [True: 0, False: 103]
  ------------------
  397|       |        // Round the significand to odd: set the lowest kept bit whenever any
  398|       |        // bit was dropped. The caller rounds this double to float; rounding to
  399|       |        // nearest here would double-round, but round-to-odd leaves that final
  400|       |        // single rounding correct for normal and subnormal results alike.
  401|      0|        if (dropped_bits != 0 || !zero_tail) {
  ------------------
  |  Branch (401:13): [True: 0, False: 0]
  |  Branch (401:34): [True: 0, False: 0]
  ------------------
  402|      0|          number |= 1;
  403|      0|        }
  404|    103|      } else {
  405|    103|        int middle_value = (1 << (overflow_bits_count - 1));
  406|    103|        if (dropped_bits > middle_value) {
  ------------------
  |  Branch (406:13): [True: 7, False: 96]
  ------------------
  407|      7|          number++;  // Rounding up.
  408|     96|        } else if (dropped_bits == middle_value) {
  ------------------
  |  Branch (408:20): [True: 44, False: 52]
  ------------------
  409|       |          // Rounding to even to consistency with decimals: half-way case rounds
  410|       |          // up if significant part is odd and down otherwise.
  411|     44|          if ((number & 1) != 0 || !zero_tail) {
  ------------------
  |  Branch (411:15): [True: 23, False: 21]
  |  Branch (411:36): [True: 7, False: 14]
  ------------------
  412|     30|            number++;  // Rounding up.
  413|     30|          }
  414|     44|        }
  415|       |
  416|       |        // Rounding up may cause overflow.
  417|    103|        if ((number & ((int64_t)1 << kSignificandSize)) != 0) {
  ------------------
  |  Branch (417:13): [True: 3, False: 100]
  ------------------
  418|      3|          exponent++;
  419|      3|          number >>= 1;
  420|      3|        }
  421|    103|      }
  422|    103|      break;
  423|    103|    }
  424|  2.77k|    if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (424:9): [True: 114, False: 2.65k]
  ------------------
  425|  2.77k|  }
  426|       |
  427|    217|  DOUBLE_CONVERSION_ASSERT(number < ((int64_t)1 << kSignificandSize));
  ------------------
  |  |   47|    217|    assert(condition)
  ------------------
  |  Branch (427:3): [True: 217, False: 0]
  ------------------
  428|    217|  DOUBLE_CONVERSION_ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
  ------------------
  |  |   47|    217|    assert(condition)
  ------------------
  |  Branch (428:3): [True: 217, False: 0]
  ------------------
  429|       |
  430|    217|  *result_is_junk = false;
  431|       |
  432|    217|  if (parse_as_hex_float) {
  ------------------
  |  Branch (432:7): [True: 0, False: 217]
  ------------------
  433|      0|    DOUBLE_CONVERSION_ASSERT(**current == 'p' || **current == 'P');
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (433:5): [True: 0, False: 0]
  |  Branch (433:5): [True: 0, False: 0]
  |  Branch (433:5): [True: 0, False: 0]
  ------------------
  434|       |    // The separator is only allowed between significand digits, not in the
  435|       |    // exponent, so advance through the exponent with no separator. This must
  436|       |    // match IsHexFloatString, which validated the string the same way.
  437|      0|    const uc16 kNoSeparator = StringToDoubleConverter::kNoSeparator;
  438|      0|    Advance(current, kNoSeparator, radix, end);
  439|      0|    DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (439:5): [True: 0, False: 0]
  ------------------
  440|      0|    bool is_negative = false;
  441|      0|    if (**current == '+') {
  ------------------
  |  Branch (441:9): [True: 0, False: 0]
  ------------------
  442|      0|      Advance(current, kNoSeparator, radix, end);
  443|      0|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (443:7): [True: 0, False: 0]
  ------------------
  444|      0|    } else if (**current == '-') {
  ------------------
  |  Branch (444:16): [True: 0, False: 0]
  ------------------
  445|      0|      is_negative = true;
  446|      0|      Advance(current, kNoSeparator, radix, end);
  447|      0|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (447:7): [True: 0, False: 0]
  ------------------
  448|      0|    }
  449|      0|    int written_exponent = 0;
  450|      0|    while (IsDecimalDigitForRadix(**current, 10)) {
  ------------------
  |  Branch (450:12): [True: 0, False: 0]
  ------------------
  451|       |      // No need to read exponents if they are too big. That could potentially overflow
  452|       |      // the `written_exponent` variable.
  453|      0|      if (abs(written_exponent) <= 100 * Double::kMaxExponent) {
  ------------------
  |  Branch (453:11): [True: 0, False: 0]
  ------------------
  454|      0|        written_exponent = 10 * written_exponent + **current - '0';
  455|      0|      }
  456|      0|      if (Advance(current, kNoSeparator, radix, end)) break;
  ------------------
  |  Branch (456:11): [True: 0, False: 0]
  ------------------
  457|      0|    }
  458|      0|    if (is_negative) written_exponent = -written_exponent;
  ------------------
  |  Branch (458:9): [True: 0, False: 0]
  ------------------
  459|      0|    exponent += written_exponent;
  460|      0|  }
  461|       |
  462|    217|  if (exponent == 0 || number == 0) {
  ------------------
  |  Branch (462:7): [True: 114, False: 103]
  |  Branch (462:24): [True: 0, False: 103]
  ------------------
  463|    114|    if (sign) {
  ------------------
  |  Branch (463:9): [True: 53, False: 61]
  ------------------
  464|     53|      if (number == 0) return -0.0;
  ------------------
  |  Branch (464:11): [True: 0, False: 53]
  ------------------
  465|     53|      number = -number;
  466|     53|    }
  467|    114|    return static_cast<double>(number);
  468|    114|  }
  469|       |
  470|    103|  DOUBLE_CONVERSION_ASSERT(number != 0);
  ------------------
  |  |   47|    103|    assert(condition)
  ------------------
  |  Branch (470:3): [True: 103, False: 0]
  ------------------
  471|       |  // number is an exact integer below 2^kSignificandSize, so number * 2^exponent
  472|       |  // can be formed directly. Double(DiyFp(number, exponent)) would instead assume
  473|       |  // a normalized significand: a hex-float like "0x1p1000" or "0x2p-1075" reaches
  474|       |  // here with a small number and a large exponent, which DiyFpToUint64 then reads
  475|       |  // as an overflow (infinity) or underflow (zero) rather than the finite result.
  476|    103|  double result = ldexp(static_cast<double>(number), exponent);
  477|    103|  return sign ? -result : result;
  ------------------
  |  Branch (477:10): [True: 1, False: 102]
  ------------------
  478|    103|}
string-to-double.cc:_ZN17double_conversionL7AdvanceIPcEEbPT_tiRS2_:
  207|  6.28k|static bool Advance (Iterator* it, uc16 separator, int base, Iterator& end) {
  208|  6.28k|  if (separator == StringToDoubleConverter::kNoSeparator) {
  ------------------
  |  Branch (208:7): [True: 6.28k, False: 0]
  ------------------
  209|  6.28k|    ++(*it);
  210|  6.28k|    return *it == end;
  211|  6.28k|  }
  212|      0|  if (!isDigit(**it, base)) {
  ------------------
  |  Branch (212:7): [True: 0, False: 0]
  ------------------
  213|      0|    ++(*it);
  214|      0|    return *it == end;
  215|      0|  }
  216|      0|  ++(*it);
  217|      0|  if (*it == end) return true;
  ------------------
  |  Branch (217:7): [True: 0, False: 0]
  ------------------
  218|      0|  if (*it + 1 == end) return false;
  ------------------
  |  Branch (218:7): [True: 0, False: 0]
  ------------------
  219|      0|  if (**it == separator && isDigit(*(*it + 1), base)) {
  ------------------
  |  Branch (219:7): [True: 0, False: 0]
  |  Branch (219:28): [True: 0, False: 0]
  ------------------
  220|      0|    ++(*it);
  221|      0|  }
  222|      0|  return *it == end;
  223|      0|}

_ZN17double_conversion23StringToDoubleConverterC2EiddPKcS2_t:
  173|  2.93k|      : flags_(flags),
  174|  2.93k|        empty_string_value_(empty_string_value),
  175|  2.93k|        junk_string_value_(junk_string_value),
  176|  2.93k|        infinity_symbol_(infinity_symbol),
  177|  2.93k|        nan_symbol_(nan_symbol),
  178|  2.93k|        separator_(separator) {
  179|  2.93k|  }

_ZN17double_conversion13StrtodTrimmedENS_6VectorIKcEEi:
  482|  1.94k|double StrtodTrimmed(Vector<const char> trimmed, int exponent) {
  483|  1.94k|  DOUBLE_CONVERSION_ASSERT(trimmed.length() <= kMaxSignificantDecimalDigits);
  ------------------
  |  |   47|  1.94k|    assert(condition)
  ------------------
  |  Branch (483:3): [True: 1.94k, False: 0]
  ------------------
  484|  1.94k|  DOUBLE_CONVERSION_ASSERT(AssertTrimmedDigits(trimmed));
  ------------------
  |  |   47|  1.94k|    assert(condition)
  ------------------
  |  Branch (484:3): [True: 1.94k, False: 0]
  ------------------
  485|  1.94k|  double guess;
  486|  1.94k|  const bool is_correct = ComputeGuess(trimmed, exponent, &guess);
  487|  1.94k|  if (is_correct) {
  ------------------
  |  Branch (487:7): [True: 1.18k, False: 753]
  ------------------
  488|  1.18k|    return guess;
  489|  1.18k|  }
  490|    753|  DiyFp upper_boundary = Double(guess).UpperBoundary();
  491|    753|  int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
  492|    753|  if (comparison < 0) {
  ------------------
  |  Branch (492:7): [True: 226, False: 527]
  ------------------
  493|    226|    return guess;
  494|    527|  } else if (comparison > 0) {
  ------------------
  |  Branch (494:14): [True: 434, False: 93]
  ------------------
  495|    434|    return Double(guess).NextDouble();
  496|    434|  } else if ((Double(guess).Significand() & 1) == 0) {
  ------------------
  |  Branch (496:14): [True: 45, False: 48]
  ------------------
  497|       |    // Round towards even.
  498|     45|    return guess;
  499|     48|  } else {
  500|     48|    return Double(guess).NextDouble();
  501|     48|  }
  502|    753|}
strtod.cc:_ZN17double_conversionL19AssertTrimmedDigitsERKNS_6VectorIKcEE:
  473|  1.94k|static bool AssertTrimmedDigits(const Vector<const char>& buffer) {
  474|   123k|  for(int i = 0; i < buffer.length(); ++i) {
  ------------------
  |  Branch (474:18): [True: 121k, False: 1.94k]
  ------------------
  475|   121k|    if(!IsDigit(buffer[i])) {
  ------------------
  |  Branch (475:8): [True: 0, False: 121k]
  ------------------
  476|      0|      return false;
  477|      0|    }
  478|   121k|  }
  479|  1.94k|  return (buffer.length() == 0) || (IsNonZeroDigit(buffer[0]) && IsNonZeroDigit(buffer[buffer.length()-1]));
  ------------------
  |  Branch (479:10): [True: 70, False: 1.87k]
  |  Branch (479:37): [True: 1.87k, False: 0]
  |  Branch (479:66): [True: 1.87k, False: 0]
  ------------------
  480|  1.94k|}
strtod.cc:_ZN17double_conversionL7IsDigitEc:
  460|   121k|static bool IsDigit(const char d) {
  461|   121k|  return ('0' <= d) && (d <= '9');
  ------------------
  |  Branch (461:10): [True: 121k, False: 0]
  |  Branch (461:24): [True: 121k, False: 0]
  ------------------
  462|   121k|}
strtod.cc:_ZN17double_conversionL14IsNonZeroDigitEc:
  464|  3.74k|static bool IsNonZeroDigit(const char d) {
  465|  3.74k|  return ('1' <= d) && (d <= '9');
  ------------------
  |  Branch (465:10): [True: 3.74k, False: 0]
  |  Branch (465:24): [True: 3.74k, False: 0]
  ------------------
  466|  3.74k|}
strtod.cc:_ZN17double_conversionL12ComputeGuessENS_6VectorIKcEEiPd:
  435|  1.94k|                         double* guess) {
  436|  1.94k|  if (trimmed.length() == 0) {
  ------------------
  |  Branch (436:7): [True: 70, False: 1.87k]
  ------------------
  437|     70|    *guess = 0.0;
  438|     70|    return true;
  439|     70|  }
  440|  1.87k|  exponent = ClampExponent(exponent);
  441|  1.87k|  if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) {
  ------------------
  |  Branch (441:7): [True: 164, False: 1.70k]
  ------------------
  442|    164|    *guess = Double::Infinity();
  443|    164|    return true;
  444|    164|  }
  445|  1.70k|  if (exponent + trimmed.length() <= kMinDecimalPower) {
  ------------------
  |  Branch (445:7): [True: 91, False: 1.61k]
  ------------------
  446|     91|    *guess = 0.0;
  447|     91|    return true;
  448|     91|  }
  449|       |
  450|  1.61k|  if (DoubleStrtod(trimmed, exponent, guess) ||
  ------------------
  |  Branch (450:7): [True: 289, False: 1.32k]
  ------------------
  451|  1.32k|      DiyFpStrtod(trimmed, exponent, guess)) {
  ------------------
  |  Branch (451:7): [True: 573, False: 754]
  ------------------
  452|    862|    return true;
  453|    862|  }
  454|    754|  if (*guess == Double::Infinity()) {
  ------------------
  |  Branch (454:7): [True: 1, False: 753]
  ------------------
  455|      1|    return true;
  456|      1|  }
  457|    753|  return false;
  458|    754|}
strtod.cc:_ZN17double_conversionL13ClampExponentEi:
  128|  1.87k|static int ClampExponent(int exponent) {
  129|  1.87k|  const int kMaxExponent = INT_MAX / 2;
  130|  1.87k|  if (exponent > kMaxExponent) return kMaxExponent;
  ------------------
  |  Branch (130:7): [True: 1, False: 1.87k]
  ------------------
  131|  1.87k|  if (exponent < -kMaxExponent) return -kMaxExponent;
  ------------------
  |  Branch (131:7): [True: 12, False: 1.85k]
  ------------------
  132|  1.85k|  return exponent;
  133|  1.87k|}
strtod.cc:_ZN17double_conversionL12DoubleStrtodENS_6VectorIKcEEiPd:
  207|  1.61k|                         double* result) {
  208|       |#if !defined(DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS)
  209|       |  // Avoid "unused parameter" warnings
  210|       |  (void) trimmed;
  211|       |  (void) exponent;
  212|       |  (void) result;
  213|       |  // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
  214|       |  // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
  215|       |  // result is not accurate.
  216|       |  // We know that Windows32 uses 64 bits and is therefore accurate.
  217|       |  return false;
  218|       |#else
  219|  1.61k|  if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
  ------------------
  |  Branch (219:7): [True: 884, False: 732]
  ------------------
  220|    884|    int read_digits;
  221|       |    // The trimmed input fits into a double.
  222|       |    // If the 10^exponent (resp. 10^-exponent) fits into a double too then we
  223|       |    // can compute the result-double simply by multiplying (resp. dividing) the
  224|       |    // two numbers.
  225|       |    // This is possible because IEEE guarantees that floating-point operations
  226|       |    // return the best possible approximation.
  227|    884|    if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
  ------------------
  |  Branch (227:9): [True: 297, False: 587]
  |  Branch (227:25): [True: 73, False: 224]
  ------------------
  228|       |      // 10^-exponent fits into a double.
  229|     73|      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
  230|     73|      DOUBLE_CONVERSION_ASSERT(read_digits == trimmed.length());
  ------------------
  |  |   47|     73|    assert(condition)
  ------------------
  |  Branch (230:7): [True: 73, False: 0]
  ------------------
  231|     73|      *result /= exact_powers_of_ten[-exponent];
  232|     73|      return true;
  233|     73|    }
  234|    811|    if (0 <= exponent && exponent < kExactPowersOfTenSize) {
  ------------------
  |  Branch (234:9): [True: 587, False: 224]
  |  Branch (234:26): [True: 162, False: 425]
  ------------------
  235|       |      // 10^exponent fits into a double.
  236|    162|      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
  237|    162|      DOUBLE_CONVERSION_ASSERT(read_digits == trimmed.length());
  ------------------
  |  |   47|    162|    assert(condition)
  ------------------
  |  Branch (237:7): [True: 162, False: 0]
  ------------------
  238|    162|      *result *= exact_powers_of_ten[exponent];
  239|    162|      return true;
  240|    162|    }
  241|    649|    int remaining_digits =
  242|    649|        kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
  243|    649|    if ((0 <= exponent) &&
  ------------------
  |  Branch (243:9): [True: 425, False: 224]
  ------------------
  244|    425|        (exponent - remaining_digits < kExactPowersOfTenSize)) {
  ------------------
  |  Branch (244:9): [True: 54, False: 371]
  ------------------
  245|       |      // The trimmed string was short and we can multiply it with
  246|       |      // 10^remaining_digits. As a result the remaining exponent now fits
  247|       |      // into a double too.
  248|     54|      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
  249|     54|      DOUBLE_CONVERSION_ASSERT(read_digits == trimmed.length());
  ------------------
  |  |   47|     54|    assert(condition)
  ------------------
  |  Branch (249:7): [True: 54, False: 0]
  ------------------
  250|     54|      *result *= exact_powers_of_ten[remaining_digits];
  251|     54|      *result *= exact_powers_of_ten[exponent - remaining_digits];
  252|     54|      return true;
  253|     54|    }
  254|    649|  }
  255|  1.32k|  return false;
  256|  1.61k|#endif
  257|  1.61k|}
strtod.cc:_ZN17double_conversionL10ReadUint64ENS_6VectorIKcEEPi:
  167|  1.61k|                           int* number_of_read_digits) {
  168|  1.61k|  uint64_t result = 0;
  169|  1.61k|  int i = 0;
  170|  19.3k|  while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
  ------------------
  |  Branch (170:10): [True: 18.1k, False: 1.26k]
  |  Branch (170:33): [True: 17.7k, False: 347]
  ------------------
  171|  17.7k|    int digit = buffer[i++] - '0';
  172|  17.7k|    DOUBLE_CONVERSION_ASSERT(0 <= digit && digit <= 9);
  ------------------
  |  |   47|  17.7k|    assert(condition)
  ------------------
  |  Branch (172:5): [True: 17.7k, False: 0]
  |  Branch (172:5): [True: 17.7k, False: 0]
  |  Branch (172:5): [True: 17.7k, False: 0]
  ------------------
  173|  17.7k|    result = 10 * result + digit;
  174|  17.7k|  }
  175|  1.61k|  *number_of_read_digits = i;
  176|  1.61k|  return result;
  177|  1.61k|}
strtod.cc:_ZN17double_conversionL11DiyFpStrtodENS_6VectorIKcEEiPd:
  287|  1.32k|                        double* result) {
  288|  1.32k|  DiyFp input;
  289|  1.32k|  int remaining_decimals;
  290|  1.32k|  ReadDiyFp(buffer, &input, &remaining_decimals);
  291|       |  // Since we may have dropped some digits the input is not accurate.
  292|       |  // If remaining_decimals is different than 0 than the error is at most
  293|       |  // .5 ulp (unit in the last place).
  294|       |  // We don't want to deal with fractions and therefore keep a common
  295|       |  // denominator.
  296|  1.32k|  const int kDenominatorLog = 3;
  297|  1.32k|  const int kDenominator = 1 << kDenominatorLog;
  298|       |  // Move the remaining decimals into the exponent.
  299|  1.32k|  exponent += remaining_decimals;
  300|  1.32k|  uint64_t error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
  ------------------
  |  Branch (300:21): [True: 980, False: 347]
  ------------------
  301|       |
  302|  1.32k|  int old_e = input.e();
  303|  1.32k|  input.Normalize();
  304|  1.32k|  error <<= old_e - input.e();
  305|       |
  306|  1.32k|  DOUBLE_CONVERSION_ASSERT(exponent <= PowersOfTenCache::kMaxDecimalExponent);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (306:3): [True: 1.32k, False: 0]
  ------------------
  307|  1.32k|  if (exponent < PowersOfTenCache::kMinDecimalExponent) {
  ------------------
  |  Branch (307:7): [True: 0, False: 1.32k]
  ------------------
  308|      0|    *result = 0.0;
  309|      0|    return true;
  310|      0|  }
  311|  1.32k|  DiyFp cached_power;
  312|  1.32k|  int cached_decimal_exponent;
  313|  1.32k|  PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent,
  314|  1.32k|                                                     &cached_power,
  315|  1.32k|                                                     &cached_decimal_exponent);
  316|       |
  317|  1.32k|  if (cached_decimal_exponent != exponent) {
  ------------------
  |  Branch (317:7): [True: 1.21k, False: 115]
  ------------------
  318|  1.21k|    int adjustment_exponent = exponent - cached_decimal_exponent;
  319|  1.21k|    DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
  320|  1.21k|    input.Multiply(adjustment_power);
  321|  1.21k|    if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
  ------------------
  |  Branch (321:9): [True: 537, False: 675]
  ------------------
  322|       |      // The product of input with the adjustment power fits into a 64 bit
  323|       |      // integer.
  324|    537|      DOUBLE_CONVERSION_ASSERT(DiyFp::kSignificandSize == 64);
  ------------------
  |  |   47|    537|    assert(condition)
  ------------------
  |  Branch (324:7): [True: 537, Folded]
  ------------------
  325|    675|    } else {
  326|       |      // The adjustment power is exact. There is hence only an error of 0.5.
  327|    675|      error += kDenominator / 2;
  328|    675|    }
  329|  1.21k|  }
  330|       |
  331|  1.32k|  input.Multiply(cached_power);
  332|       |  // The error introduced by a multiplication of a*b equals
  333|       |  //   error_a + error_b + error_a*error_b/2^64 + 0.5
  334|       |  // Substituting a with 'input' and b with 'cached_power' we have
  335|       |  //   error_b = 0.5  (all cached powers have an error of less than 0.5 ulp),
  336|       |  //   error_ab = 0 or 1 / kDenominator > error_a*error_b/ 2^64
  337|  1.32k|  int error_b = kDenominator / 2;
  338|  1.32k|  int error_ab = (error == 0 ? 0 : 1);  // We round up to 1.
  ------------------
  |  Branch (338:19): [True: 613, False: 714]
  ------------------
  339|  1.32k|  int fixed_error = kDenominator / 2;
  340|  1.32k|  error += error_b + error_ab + fixed_error;
  341|       |
  342|  1.32k|  old_e = input.e();
  343|  1.32k|  input.Normalize();
  344|  1.32k|  error <<= old_e - input.e();
  345|       |
  346|       |  // See if the double's significand changes if we add/subtract the error.
  347|  1.32k|  int order_of_magnitude = DiyFp::kSignificandSize + input.e();
  348|  1.32k|  int effective_significand_size =
  349|  1.32k|      Double::SignificandSizeForOrderOfMagnitude(order_of_magnitude);
  350|  1.32k|  int precision_digits_count =
  351|  1.32k|      DiyFp::kSignificandSize - effective_significand_size;
  352|  1.32k|  if (precision_digits_count + kDenominatorLog >= DiyFp::kSignificandSize) {
  ------------------
  |  Branch (352:7): [True: 56, False: 1.27k]
  ------------------
  353|       |    // This can only happen for very small denormals. In this case the
  354|       |    // half-way multiplied by the denominator exceeds the range of an uint64.
  355|       |    // Simply shift everything to the right.
  356|     56|    int shift_amount = (precision_digits_count + kDenominatorLog) -
  357|     56|        DiyFp::kSignificandSize + 1;
  358|     56|    input.set_f(input.f() >> shift_amount);
  359|     56|    input.set_e(input.e() + shift_amount);
  360|       |    // We add 1 for the lost precision of error, and kDenominator for
  361|       |    // the lost precision of input.f().
  362|     56|    error = (error >> shift_amount) + 1 + kDenominator;
  363|     56|    precision_digits_count -= shift_amount;
  364|     56|  }
  365|       |  // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too.
  366|  1.32k|  DOUBLE_CONVERSION_ASSERT(DiyFp::kSignificandSize == 64);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (366:3): [True: 1.32k, Folded]
  ------------------
  367|  1.32k|  DOUBLE_CONVERSION_ASSERT(precision_digits_count < 64);
  ------------------
  |  |   47|  1.32k|    assert(condition)
  ------------------
  |  Branch (367:3): [True: 1.32k, False: 0]
  ------------------
  368|  1.32k|  uint64_t one64 = 1;
  369|  1.32k|  uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
  370|  1.32k|  uint64_t precision_bits = input.f() & precision_bits_mask;
  371|  1.32k|  uint64_t half_way = one64 << (precision_digits_count - 1);
  372|  1.32k|  precision_bits *= kDenominator;
  373|  1.32k|  half_way *= kDenominator;
  374|  1.32k|  DiyFp rounded_input(input.f() >> precision_digits_count,
  375|  1.32k|                      input.e() + precision_digits_count);
  376|  1.32k|  if (precision_bits >= half_way + error) {
  ------------------
  |  Branch (376:7): [True: 262, False: 1.06k]
  ------------------
  377|    262|    rounded_input.set_f(rounded_input.f() + 1);
  378|    262|  }
  379|       |  // If the last_bits are too close to the half-way case than we are too
  380|       |  // inaccurate and round down. In this case we return false so that we can
  381|       |  // fall back to a more precise algorithm.
  382|       |
  383|  1.32k|  *result = Double(rounded_input).value();
  384|  1.32k|  if (half_way - error < precision_bits && precision_bits < half_way + error) {
  ------------------
  |  Branch (384:7): [True: 1.01k, False: 311]
  |  Branch (384:44): [True: 754, False: 262]
  ------------------
  385|       |    // Too imprecise. The caller will have to fall back to a slower version.
  386|       |    // However the returned number is guaranteed to be either the correct
  387|       |    // double, or the next-lower double.
  388|    754|    return false;
  389|    754|  } else {
  390|    573|    return true;
  391|    573|  }
  392|  1.32k|}
strtod.cc:_ZN17double_conversionL9ReadDiyFpENS_6VectorIKcEEPNS_5DiyFpEPi:
  186|  1.32k|                      int* remaining_decimals) {
  187|  1.32k|  int read_digits;
  188|  1.32k|  uint64_t significand = ReadUint64(buffer, &read_digits);
  189|  1.32k|  if (buffer.length() == read_digits) {
  ------------------
  |  Branch (189:7): [True: 980, False: 347]
  ------------------
  190|    980|    *result = DiyFp(significand, 0);
  191|    980|    *remaining_decimals = 0;
  192|    980|  } else {
  193|       |    // Round the significand.
  194|    347|    if (buffer[read_digits] >= '5') {
  ------------------
  |  Branch (194:9): [True: 88, False: 259]
  ------------------
  195|     88|      significand++;
  196|     88|    }
  197|       |    // Compute the binary exponent.
  198|    347|    int exponent = 0;
  199|    347|    *result = DiyFp(significand, exponent);
  200|    347|    *remaining_decimals = buffer.length() - read_digits;
  201|    347|  }
  202|  1.32k|}
strtod.cc:_ZN17double_conversionL20AdjustmentPowerOfTenEi:
  262|  1.21k|static DiyFp AdjustmentPowerOfTen(int exponent) {
  263|  1.21k|  DOUBLE_CONVERSION_ASSERT(0 < exponent);
  ------------------
  |  |   47|  1.21k|    assert(condition)
  ------------------
  |  Branch (263:3): [True: 1.21k, False: 0]
  ------------------
  264|  1.21k|  DOUBLE_CONVERSION_ASSERT(exponent < PowersOfTenCache::kDecimalExponentDistance);
  ------------------
  |  |   47|  1.21k|    assert(condition)
  ------------------
  |  Branch (264:3): [True: 1.21k, False: 0]
  ------------------
  265|       |  // Simply hardcode the remaining powers for the given decimal exponent
  266|       |  // distance.
  267|  1.21k|  DOUBLE_CONVERSION_ASSERT(PowersOfTenCache::kDecimalExponentDistance == 8);
  ------------------
  |  |   47|  1.21k|    assert(condition)
  ------------------
  |  Branch (267:3): [True: 1.21k, Folded]
  ------------------
  268|  1.21k|  switch (exponent) {
  269|    172|    case 1: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xa0000000, 00000000), -60);
  ------------------
  |  |  195|    172|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (269:5): [True: 172, False: 1.04k]
  ------------------
  270|    107|    case 2: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xc8000000, 00000000), -57);
  ------------------
  |  |  195|    107|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (270:5): [True: 107, False: 1.10k]
  ------------------
  271|    124|    case 3: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xfa000000, 00000000), -54);
  ------------------
  |  |  195|    124|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (271:5): [True: 124, False: 1.08k]
  ------------------
  272|    399|    case 4: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0x9c400000, 00000000), -50);
  ------------------
  |  |  195|    399|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (272:5): [True: 399, False: 813]
  ------------------
  273|    143|    case 5: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xc3500000, 00000000), -47);
  ------------------
  |  |  195|    143|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (273:5): [True: 143, False: 1.06k]
  ------------------
  274|    109|    case 6: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0xf4240000, 00000000), -44);
  ------------------
  |  |  195|    109|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (274:5): [True: 109, False: 1.10k]
  ------------------
  275|    158|    case 7: return DiyFp(DOUBLE_CONVERSION_UINT64_2PART_C(0x98968000, 00000000), -40);
  ------------------
  |  |  195|    158|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  |  Branch (275:5): [True: 158, False: 1.05k]
  ------------------
  276|      0|    default:
  ------------------
  |  Branch (276:5): [True: 0, False: 1.21k]
  ------------------
  277|      0|      DOUBLE_CONVERSION_UNREACHABLE();
  ------------------
  |  |   77|      0|#define DOUBLE_CONVERSION_UNREACHABLE()   (abort())
  ------------------
  278|  1.21k|  }
  279|  1.21k|}
strtod.cc:_ZN17double_conversionL22CompareBufferWithDiyFpENS_6VectorIKcEEiNS_5DiyFpE:
  405|    753|                                  DiyFp diy_fp) {
  406|    753|  DOUBLE_CONVERSION_ASSERT(buffer.length() + exponent <= kMaxDecimalPower + 1);
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (406:3): [True: 753, False: 0]
  ------------------
  407|    753|  DOUBLE_CONVERSION_ASSERT(buffer.length() + exponent > kMinDecimalPower);
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (407:3): [True: 753, False: 0]
  ------------------
  408|    753|  DOUBLE_CONVERSION_ASSERT(buffer.length() <= kMaxSignificantDecimalDigits);
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (408:3): [True: 753, False: 0]
  ------------------
  409|       |  // Make sure that the Bignum will be able to hold all our numbers.
  410|       |  // Our Bignum implementation has a separate field for exponents. Shifts will
  411|       |  // consume at most one bigit (< 64 bits).
  412|       |  // ln(10) == 3.3219...
  413|    753|  DOUBLE_CONVERSION_ASSERT(((kMaxDecimalPower + 1) * 333 / 100) < Bignum::kMaxSignificantBits);
  ------------------
  |  |   47|    753|    assert(condition)
  ------------------
  |  Branch (413:3): [True: 753, Folded]
  ------------------
  414|    753|  Bignum buffer_bignum;
  415|    753|  Bignum diy_fp_bignum;
  416|    753|  buffer_bignum.AssignDecimalString(buffer);
  417|    753|  diy_fp_bignum.AssignUInt64(diy_fp.f());
  418|    753|  if (exponent >= 0) {
  ------------------
  |  Branch (418:7): [True: 424, False: 329]
  ------------------
  419|    424|    buffer_bignum.MultiplyByPowerOfTen(exponent);
  420|    424|  } else {
  421|    329|    diy_fp_bignum.MultiplyByPowerOfTen(-exponent);
  422|    329|  }
  423|    753|  if (diy_fp.e() > 0) {
  ------------------
  |  Branch (423:7): [True: 393, False: 360]
  ------------------
  424|    393|    diy_fp_bignum.ShiftLeft(diy_fp.e());
  425|    393|  } else {
  426|    360|    buffer_bignum.ShiftLeft(-diy_fp.e());
  427|    360|  }
  428|    753|  return Bignum::Compare(buffer_bignum, diy_fp_bignum);
  429|    753|}

_ZN17double_conversion17TrimTrailingZerosENS_6VectorIKcEE:
   53|  1.94k|inline Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
   54|  6.91k|  for (int i = buffer.length() - 1; i >= 0; --i) {
  ------------------
  |  Branch (54:37): [True: 6.84k, False: 70]
  ------------------
   55|  6.84k|    if (buffer[i] != '0') {
  ------------------
  |  Branch (55:9): [True: 1.87k, False: 4.97k]
  ------------------
   56|  1.87k|      return buffer.SubVector(0, i + 1);
   57|  1.87k|    }
   58|  6.84k|  }
   59|     70|  return Vector<const char>(buffer.start(), 0);
   60|  1.94k|}

_ZN17double_conversion7BitCastIdmEET_RKT0_:
  395|  2.73k|Dest BitCast(const Source& source) {
  396|       |  // Compile time assertion: sizeof(Dest) == sizeof(Source)
  397|       |  // A compile error here means your Dest and Source have different sizes.
  398|  2.73k|#if __cplusplus >= 201103L
  399|  2.73k|  static_assert(sizeof(Dest) == sizeof(Source),
  400|  2.73k|                "source and destination size mismatch");
  401|       |#else
  402|       |  DOUBLE_CONVERSION_UNUSED
  403|       |  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
  404|       |#endif
  405|       |
  406|  2.73k|  Dest dest;
  407|  2.73k|  memmove(&dest, &source, sizeof(dest));
  408|  2.73k|  return dest;
  409|  2.73k|}
_ZN17double_conversion6VectorIKcEC2EPS1_i:
  252|  3.88k|  Vector(T* data, int len) : start_(data), length_(len) {
  253|       |    DOUBLE_CONVERSION_ASSERT(len == 0 || (len > 0 && data != DOUBLE_CONVERSION_NULLPTR));
  ------------------
  |  |   47|  3.88k|    assert(condition)
  ------------------
  |  Branch (253:5): [True: 3.74k, False: 0]
  |  Branch (253:5): [True: 3.74k, False: 0]
  |  Branch (253:5): [True: 140, False: 3.74k]
  |  Branch (253:5): [True: 3.88k, False: 0]
  ------------------
  254|  3.88k|  }
_ZNK17double_conversion6VectorIKcEixEi:
  275|   222k|  T& operator[](int index) const {
  276|   222k|    DOUBLE_CONVERSION_ASSERT(0 <= index && index < length_);
  ------------------
  |  |   47|   222k|    assert(condition)
  ------------------
  |  Branch (276:5): [True: 222k, False: 0]
  |  Branch (276:5): [True: 222k, False: 0]
  |  Branch (276:5): [True: 222k, False: 0]
  ------------------
  277|   222k|    return start_[index];
  278|   222k|  }
_ZN17double_conversion6VectorIKcE9SubVectorEii:
  258|  1.87k|  Vector<T> SubVector(int from, int to) {
  259|  1.87k|    DOUBLE_CONVERSION_ASSERT(to <= length_);
  ------------------
  |  |   47|  1.87k|    assert(condition)
  ------------------
  |  Branch (259:5): [True: 1.87k, False: 0]
  ------------------
  260|  1.87k|    DOUBLE_CONVERSION_ASSERT(from < to);
  ------------------
  |  |   47|  1.87k|    assert(condition)
  ------------------
  |  Branch (260:5): [True: 1.87k, False: 0]
  ------------------
  261|  1.87k|    DOUBLE_CONVERSION_ASSERT(0 <= from);
  ------------------
  |  |   47|  1.87k|    assert(condition)
  ------------------
  |  Branch (261:5): [True: 1.87k, False: 0]
  ------------------
  262|  1.87k|    return Vector<T>(start() + from, to - from);
  263|  1.87k|  }
_ZNK17double_conversion6VectorIKcE5startEv:
  272|  1.94k|  T* start() const { return start_; }
_ZNK17double_conversion6VectorIKcE6lengthEv:
  266|   166k|  int length() const { return length_; }
_ZN17double_conversion7BitCastImdEET_RKT0_:
  395|  1.32k|Dest BitCast(const Source& source) {
  396|       |  // Compile time assertion: sizeof(Dest) == sizeof(Source)
  397|       |  // A compile error here means your Dest and Source have different sizes.
  398|  1.32k|#if __cplusplus >= 201103L
  399|  1.32k|  static_assert(sizeof(Dest) == sizeof(Source),
  400|  1.32k|                "source and destination size mismatch");
  401|       |#else
  402|       |  DOUBLE_CONVERSION_UNUSED
  403|       |  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
  404|       |#endif
  405|       |
  406|  1.32k|  Dest dest;
  407|  1.32k|  memmove(&dest, &source, sizeof(dest));
  408|  1.32k|  return dest;
  409|  1.32k|}

LLVMFuzzerTestOneInput:
   23|  2.93k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   24|  2.93k|  StringToDoubleConverter converter(
   25|  2.93k|      StringToDoubleConverter::ALLOW_HEX |
   26|  2.93k|          StringToDoubleConverter::ALLOW_OCTALS |
   27|  2.93k|          StringToDoubleConverter::ALLOW_TRAILING_JUNK |
   28|  2.93k|          StringToDoubleConverter::ALLOW_LEADING_SPACES |
   29|  2.93k|          StringToDoubleConverter::ALLOW_TRAILING_SPACES |
   30|  2.93k|          StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
   31|  2.93k|          StringToDoubleConverter::ALLOW_CASE_INSENSIBILITY |
   32|  2.93k|          StringToDoubleConverter::ALLOW_HEX_FLOATS,
   33|  2.93k|      /*empty_string_value=*/0.0,
   34|  2.93k|      /*junk_string_value=*/0.0, "inf", "nan");
   35|  2.93k|  int num_digits_unused;
   36|  2.93k|  converter.StringToDouble(reinterpret_cast<const char*>(data), size,
   37|  2.93k|                           &num_digits_unused);
   38|  2.93k|  return 0;
   39|  2.93k|}