_ZN17double_conversion6Bignum8RawBigitEi:
   36|  1.12M|Bignum::Chunk& Bignum::RawBigit(const int index) {
   37|  1.12M|  DOUBLE_CONVERSION_ASSERT(static_cast<unsigned>(index) < kBigitCapacity);
  ------------------
  |  |   47|  1.12M|    assert(condition)
  ------------------
  |  Branch (37:3): [True: 1.12M, False: 0]
  ------------------
   38|  1.12M|  return bigits_buffer_[index];
   39|  1.12M|}
_ZNK17double_conversion6Bignum8RawBigitEi:
   42|  19.6k|const Bignum::Chunk& Bignum::RawBigit(const int index) const {
   43|  19.6k|  DOUBLE_CONVERSION_ASSERT(static_cast<unsigned>(index) < kBigitCapacity);
  ------------------
  |  |   47|  19.6k|    assert(condition)
  ------------------
  |  Branch (43:3): [True: 19.6k, False: 0]
  ------------------
   44|  19.6k|  return bigits_buffer_[index];
   45|  19.6k|}
_ZN17double_conversion6Bignum12AssignUInt64Em:
   59|  3.32k|void Bignum::AssignUInt64(uint64_t value) {
   60|  3.32k|  Zero();
   61|  10.7k|  for(int i = 0; value > 0; ++i) {
  ------------------
  |  Branch (61:18): [True: 7.44k, False: 3.32k]
  ------------------
   62|  7.44k|    RawBigit(i) = value & kBigitMask;
   63|  7.44k|    value >>= kBigitSize;
   64|  7.44k|    ++used_bigits_;
   65|  7.44k|  }
   66|  3.32k|}
_ZN17double_conversion6Bignum19AssignDecimalStringENS_6VectorIKcEE:
   91|    787|void Bignum::AssignDecimalString(const Vector<const char> value) {
   92|       |  // 2^64 = 18446744073709551616 > 10^19
   93|    787|  static const int kMaxUint64DecimalDigits = 19;
   94|    787|  Zero();
   95|    787|  int length = value.length();
   96|    787|  unsigned pos = 0;
   97|       |  // Let's just say that each digit needs 4 bits.
   98|  4.39k|  while (length >= kMaxUint64DecimalDigits) {
  ------------------
  |  Branch (98:10): [True: 3.60k, False: 787]
  ------------------
   99|  3.60k|    const uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
  100|  3.60k|    pos += kMaxUint64DecimalDigits;
  101|  3.60k|    length -= kMaxUint64DecimalDigits;
  102|  3.60k|    MultiplyByPowerOfTen(kMaxUint64DecimalDigits);
  103|  3.60k|    AddUInt64(digits);
  104|  3.60k|  }
  105|    787|  const uint64_t digits = ReadUInt64(value, pos, length);
  106|    787|  MultiplyByPowerOfTen(length);
  107|    787|  AddUInt64(digits);
  108|    787|  Clamp();
  109|    787|}
_ZN17double_conversion6Bignum9AddUInt64Em:
  150|  4.39k|void Bignum::AddUInt64(const uint64_t operand) {
  151|  4.39k|  if (operand == 0) {
  ------------------
  |  Branch (151:7): [True: 1.86k, False: 2.53k]
  ------------------
  152|  1.86k|    return;
  153|  1.86k|  }
  154|  2.53k|  Bignum other;
  155|  2.53k|  other.AssignUInt64(operand);
  156|  2.53k|  AddBignum(other);
  157|  2.53k|}
_ZN17double_conversion6Bignum9AddBignumERKS0_:
  160|  2.53k|void Bignum::AddBignum(const Bignum& other) {
  161|  2.53k|  DOUBLE_CONVERSION_ASSERT(IsClamped());
  ------------------
  |  |   47|  2.53k|    assert(condition)
  ------------------
  |  Branch (161:3): [True: 2.53k, False: 0]
  ------------------
  162|  2.53k|  DOUBLE_CONVERSION_ASSERT(other.IsClamped());
  ------------------
  |  |   47|  2.53k|    assert(condition)
  ------------------
  |  Branch (162:3): [True: 2.53k, False: 0]
  ------------------
  163|       |
  164|       |  // If this has a greater exponent than other append zero-bigits to this.
  165|       |  // After this call exponent_ <= other.exponent_.
  166|  2.53k|  Align(other);
  167|       |
  168|       |  // There are two possibilities:
  169|       |  //   aaaaaaaaaaa 0000  (where the 0s represent a's exponent)
  170|       |  //     bbbbb 00000000
  171|       |  //   ----------------
  172|       |  //   ccccccccccc 0000
  173|       |  // or
  174|       |  //    aaaaaaaaaa 0000
  175|       |  //  bbbbbbbbb 0000000
  176|       |  //  -----------------
  177|       |  //  cccccccccccc 0000
  178|       |  // In both cases we might need a carry bigit.
  179|       |
  180|  2.53k|  EnsureCapacity(1 + (std::max)(BigitLength(), other.BigitLength()) - exponent_);
  181|  2.53k|  Chunk carry = 0;
  182|  2.53k|  int bigit_pos = other.exponent_ - exponent_;
  183|  2.53k|  DOUBLE_CONVERSION_ASSERT(bigit_pos >= 0);
  ------------------
  |  |   47|  2.53k|    assert(condition)
  ------------------
  |  Branch (183:3): [True: 2.53k, False: 0]
  ------------------
  184|  2.53k|  for (int i = used_bigits_; i < bigit_pos; ++i) {
  ------------------
  |  Branch (184:30): [True: 0, False: 2.53k]
  ------------------
  185|      0|    RawBigit(i) = 0;
  186|      0|  }
  187|  8.43k|  for (int i = 0; i < other.used_bigits_; ++i) {
  ------------------
  |  Branch (187:19): [True: 5.89k, False: 2.53k]
  ------------------
  188|  5.89k|    const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0;
  ------------------
  |  Branch (188:22): [True: 4.14k, False: 1.75k]
  ------------------
  189|  5.89k|    const Chunk sum = my + other.RawBigit(i) + carry;
  190|  5.89k|    RawBigit(bigit_pos) = sum & kBigitMask;
  191|  5.89k|    carry = sum >> kBigitSize;
  192|  5.89k|    ++bigit_pos;
  193|  5.89k|  }
  194|  2.89k|  while (carry != 0) {
  ------------------
  |  Branch (194:10): [True: 363, False: 2.53k]
  ------------------
  195|    363|    const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0;
  ------------------
  |  Branch (195:22): [True: 363, False: 0]
  ------------------
  196|    363|    const Chunk sum = my + carry;
  197|    363|    RawBigit(bigit_pos) = sum & kBigitMask;
  198|    363|    carry = sum >> kBigitSize;
  199|    363|    ++bigit_pos;
  200|    363|  }
  201|  2.53k|  used_bigits_ = static_cast<int16_t>(std::max(bigit_pos, static_cast<int>(used_bigits_)));
  202|       |  DOUBLE_CONVERSION_ASSERT(IsClamped());
  ------------------
  |  |   47|  2.53k|    assert(condition)
  ------------------
  |  Branch (202:3): [True: 2.53k, False: 0]
  ------------------
  203|  2.53k|}
_ZN17double_conversion6Bignum9ShiftLeftEi:
  233|  4.81k|void Bignum::ShiftLeft(const int shift_amount) {
  234|  4.81k|  if (shift_amount <= 0 || used_bigits_ == 0) {
  ------------------
  |  Branch (234:7): [True: 91, False: 4.71k]
  |  Branch (234:28): [True: 0, False: 4.71k]
  ------------------
  235|     91|    return;
  236|     91|  }
  237|  4.71k|  exponent_ += static_cast<int16_t>(shift_amount / kBigitSize);
  238|  4.71k|  const int local_shift = shift_amount % kBigitSize;
  239|  4.71k|  EnsureCapacity(used_bigits_ + 1);
  240|  4.71k|  BigitsShiftLeft(local_shift);
  241|  4.71k|}
_ZN17double_conversion6Bignum16MultiplyByUInt32Ej:
  244|  7.53k|void Bignum::MultiplyByUInt32(const uint32_t factor) {
  245|  7.53k|  if (factor == 1) {
  ------------------
  |  Branch (245:7): [True: 0, False: 7.53k]
  ------------------
  246|      0|    return;
  247|      0|  }
  248|  7.53k|  if (factor == 0) {
  ------------------
  |  Branch (248:7): [True: 0, False: 7.53k]
  ------------------
  249|      0|    Zero();
  250|      0|    return;
  251|      0|  }
  252|  7.53k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (252:7): [True: 0, False: 7.53k]
  ------------------
  253|      0|    return;
  254|      0|  }
  255|       |  // The product of a bigit with the factor is of size kBigitSize + 32.
  256|       |  // Assert that this number + 1 (for the carry) fits into double chunk.
  257|  7.53k|  DOUBLE_CONVERSION_ASSERT(kDoubleChunkSize >= kBigitSize + 32 + 1);
  ------------------
  |  |   47|  7.53k|    assert(condition)
  ------------------
  |  Branch (257:3): [True: 7.53k, Folded]
  ------------------
  258|  7.53k|  DoubleChunk carry = 0;
  259|   229k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (259:19): [True: 221k, False: 7.53k]
  ------------------
  260|   221k|    const DoubleChunk product = static_cast<DoubleChunk>(factor) * RawBigit(i) + carry;
  261|   221k|    RawBigit(i) = static_cast<Chunk>(product & kBigitMask);
  262|   221k|    carry = (product >> kBigitSize);
  263|   221k|  }
  264|  13.3k|  while (carry != 0) {
  ------------------
  |  Branch (264:10): [True: 5.85k, False: 7.53k]
  ------------------
  265|  5.85k|    EnsureCapacity(used_bigits_ + 1);
  266|  5.85k|    RawBigit(used_bigits_) = carry & kBigitMask;
  267|  5.85k|    used_bigits_++;
  268|  5.85k|    carry >>= kBigitSize;
  269|  5.85k|  }
  270|  7.53k|}
_ZN17double_conversion6Bignum16MultiplyByUInt64Em:
  273|  4.61k|void Bignum::MultiplyByUInt64(const uint64_t factor) {
  274|  4.61k|  if (factor == 1) {
  ------------------
  |  Branch (274:7): [True: 0, False: 4.61k]
  ------------------
  275|      0|    return;
  276|      0|  }
  277|  4.61k|  if (factor == 0) {
  ------------------
  |  Branch (277:7): [True: 0, False: 4.61k]
  ------------------
  278|      0|    Zero();
  279|      0|    return;
  280|      0|  }
  281|  4.61k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (281:7): [True: 0, False: 4.61k]
  ------------------
  282|      0|    return;
  283|      0|  }
  284|  4.61k|  DOUBLE_CONVERSION_ASSERT(kBigitSize < 32);
  ------------------
  |  |   47|  4.61k|    assert(condition)
  ------------------
  |  Branch (284:3): [True: 4.61k, Folded]
  ------------------
  285|  4.61k|  uint64_t carry = 0;
  286|  4.61k|  const uint64_t low = factor & 0xFFFFFFFF;
  287|  4.61k|  const uint64_t high = factor >> 32;
  288|  93.0k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (288:19): [True: 88.4k, False: 4.61k]
  ------------------
  289|  88.4k|    const uint64_t product_low = low * RawBigit(i);
  290|  88.4k|    const uint64_t product_high = high * RawBigit(i);
  291|  88.4k|    const uint64_t tmp = (carry & kBigitMask) + product_low;
  292|  88.4k|    RawBigit(i) = tmp & kBigitMask;
  293|  88.4k|    carry = (carry >> kBigitSize) + (tmp >> kBigitSize) +
  294|  88.4k|        (product_high << (32 - kBigitSize));
  295|  88.4k|  }
  296|  15.0k|  while (carry != 0) {
  ------------------
  |  Branch (296:10): [True: 10.3k, False: 4.61k]
  ------------------
  297|  10.3k|    EnsureCapacity(used_bigits_ + 1);
  298|  10.3k|    RawBigit(used_bigits_) = carry & kBigitMask;
  299|  10.3k|    used_bigits_++;
  300|  10.3k|    carry >>= kBigitSize;
  301|  10.3k|  }
  302|  4.61k|}
_ZN17double_conversion6Bignum20MultiplyByPowerOfTenEi:
  305|  5.18k|void Bignum::MultiplyByPowerOfTen(const int exponent) {
  306|  5.18k|  static const uint64_t kFive27 = DOUBLE_CONVERSION_UINT64_2PART_C(0x6765c793, fa10079d);
  ------------------
  |  |  195|  5.18k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  307|  5.18k|  static const uint16_t kFive1 = 5;
  308|  5.18k|  static const uint16_t kFive2 = kFive1 * 5;
  309|  5.18k|  static const uint16_t kFive3 = kFive2 * 5;
  310|  5.18k|  static const uint16_t kFive4 = kFive3 * 5;
  311|  5.18k|  static const uint16_t kFive5 = kFive4 * 5;
  312|  5.18k|  static const uint16_t kFive6 = kFive5 * 5;
  313|  5.18k|  static const uint32_t kFive7 = kFive6 * 5;
  314|  5.18k|  static const uint32_t kFive8 = kFive7 * 5;
  315|  5.18k|  static const uint32_t kFive9 = kFive8 * 5;
  316|  5.18k|  static const uint32_t kFive10 = kFive9 * 5;
  317|  5.18k|  static const uint32_t kFive11 = kFive10 * 5;
  318|  5.18k|  static const uint32_t kFive12 = kFive11 * 5;
  319|  5.18k|  static const uint32_t kFive13 = kFive12 * 5;
  320|  5.18k|  static const uint32_t kFive1_to_12[] =
  321|  5.18k|      { kFive1, kFive2, kFive3, kFive4, kFive5, kFive6,
  322|  5.18k|        kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 };
  323|       |
  324|  5.18k|  if (exponent <= 0) {
  ------------------
  |  Branch (324:7): [True: 373, False: 4.81k]
  ------------------
  325|    373|    return;
  326|    373|  }
  327|  4.81k|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (327:7): [True: 787, False: 4.02k]
  ------------------
  328|    787|    return;
  329|    787|  }
  330|       |  // We shift by exponent at the end just before returning.
  331|  4.02k|  int remaining_exponent = exponent;
  332|  8.63k|  while (remaining_exponent >= 27) {
  ------------------
  |  Branch (332:10): [True: 4.61k, False: 4.02k]
  ------------------
  333|  4.61k|    MultiplyByUInt64(kFive27);
  334|  4.61k|    remaining_exponent -= 27;
  335|  4.61k|  }
  336|  7.67k|  while (remaining_exponent >= 13) {
  ------------------
  |  Branch (336:10): [True: 3.65k, False: 4.02k]
  ------------------
  337|  3.65k|    MultiplyByUInt32(kFive13);
  338|  3.65k|    remaining_exponent -= 13;
  339|  3.65k|  }
  340|  4.02k|  if (remaining_exponent > 0) {
  ------------------
  |  Branch (340:7): [True: 3.88k, False: 138]
  ------------------
  341|  3.88k|    MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]);
  342|  3.88k|  }
  343|  4.02k|  ShiftLeft(exponent);
  344|  4.02k|}
_ZNK17double_conversion6Bignum11BigitOrZeroEi:
  624|  5.60k|Bignum::Chunk Bignum::BigitOrZero(const int index) const {
  625|  5.60k|  if (index >= BigitLength()) {
  ------------------
  |  Branch (625:7): [True: 0, False: 5.60k]
  ------------------
  626|      0|    return 0;
  627|      0|  }
  628|  5.60k|  if (index < exponent_) {
  ------------------
  |  Branch (628:7): [True: 253, False: 5.35k]
  ------------------
  629|    253|    return 0;
  630|    253|  }
  631|  5.35k|  return RawBigit(index - exponent_);
  632|  5.60k|}
_ZN17double_conversion6Bignum7CompareERKS0_S2_:
  635|    787|int Bignum::Compare(const Bignum& a, const Bignum& b) {
  636|    787|  DOUBLE_CONVERSION_ASSERT(a.IsClamped());
  ------------------
  |  |   47|    787|    assert(condition)
  ------------------
  |  Branch (636:3): [True: 787, False: 0]
  ------------------
  637|    787|  DOUBLE_CONVERSION_ASSERT(b.IsClamped());
  ------------------
  |  |   47|    787|    assert(condition)
  ------------------
  |  Branch (637:3): [True: 787, False: 0]
  ------------------
  638|    787|  const int bigit_length_a = a.BigitLength();
  639|    787|  const int bigit_length_b = b.BigitLength();
  640|    787|  if (bigit_length_a < bigit_length_b) {
  ------------------
  |  Branch (640:7): [True: 6, False: 781]
  ------------------
  641|      6|    return -1;
  642|      6|  }
  643|    781|  if (bigit_length_a > bigit_length_b) {
  ------------------
  |  Branch (643:7): [True: 0, False: 781]
  ------------------
  644|      0|    return +1;
  645|      0|  }
  646|  2.91k|  for (int i = bigit_length_a - 1; i >= (std::min)(a.exponent_, b.exponent_); --i) {
  ------------------
  |  Branch (646:36): [True: 2.80k, False: 107]
  ------------------
  647|  2.80k|    const Chunk bigit_a = a.BigitOrZero(i);
  648|  2.80k|    const Chunk bigit_b = b.BigitOrZero(i);
  649|  2.80k|    if (bigit_a < bigit_b) {
  ------------------
  |  Branch (649:9): [True: 232, False: 2.57k]
  ------------------
  650|    232|      return -1;
  651|    232|    }
  652|  2.57k|    if (bigit_a > bigit_b) {
  ------------------
  |  Branch (652:9): [True: 442, False: 2.13k]
  ------------------
  653|    442|      return +1;
  654|    442|    }
  655|       |    // Otherwise they are equal up to this digit. Try the next digit.
  656|  2.57k|  }
  657|    107|  return 0;
  658|    781|}
_ZN17double_conversion6Bignum5ClampEv:
  706|    787|void Bignum::Clamp() {
  707|    787|  while (used_bigits_ > 0 && RawBigit(used_bigits_ - 1) == 0) {
  ------------------
  |  Branch (707:10): [True: 787, False: 0]
  |  Branch (707:30): [True: 0, False: 787]
  ------------------
  708|      0|    used_bigits_--;
  709|      0|  }
  710|    787|  if (used_bigits_ == 0) {
  ------------------
  |  Branch (710:7): [True: 0, False: 787]
  ------------------
  711|       |    // Zero.
  712|      0|    exponent_ = 0;
  713|      0|  }
  714|    787|}
_ZN17double_conversion6Bignum5AlignERKS0_:
  717|  2.53k|void Bignum::Align(const Bignum& other) {
  718|  2.53k|  if (exponent_ > other.exponent_) {
  ------------------
  |  Branch (718:7): [True: 0, False: 2.53k]
  ------------------
  719|       |    // If "X" represents a "hidden" bigit (by the exponent) then we are in the
  720|       |    // following case (a == this, b == other):
  721|       |    // a:  aaaaaaXXXX   or a:   aaaaaXXX
  722|       |    // b:     bbbbbbX      b: bbbbbbbbXX
  723|       |    // We replace some of the hidden digits (X) of a with 0 digits.
  724|       |    // a:  aaaaaa000X   or a:   aaaaa0XX
  725|      0|    const int zero_bigits = exponent_ - other.exponent_;
  726|      0|    EnsureCapacity(used_bigits_ + zero_bigits);
  727|      0|    for (int i = used_bigits_ - 1; i >= 0; --i) {
  ------------------
  |  Branch (727:36): [True: 0, False: 0]
  ------------------
  728|      0|      RawBigit(i + zero_bigits) = RawBigit(i);
  729|      0|    }
  730|      0|    for (int i = 0; i < zero_bigits; ++i) {
  ------------------
  |  Branch (730:21): [True: 0, False: 0]
  ------------------
  731|      0|      RawBigit(i) = 0;
  732|      0|    }
  733|      0|    used_bigits_ += static_cast<int16_t>(zero_bigits);
  734|      0|    exponent_ -= static_cast<int16_t>(zero_bigits);
  735|       |
  736|      0|    DOUBLE_CONVERSION_ASSERT(used_bigits_ >= 0);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (736:5): [True: 0, False: 0]
  ------------------
  737|      0|    DOUBLE_CONVERSION_ASSERT(exponent_ >= 0);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (737:5): [True: 0, False: 0]
  ------------------
  738|      0|  }
  739|  2.53k|}
_ZN17double_conversion6Bignum15BigitsShiftLeftEi:
  742|  4.71k|void Bignum::BigitsShiftLeft(const int shift_amount) {
  743|  4.71k|  DOUBLE_CONVERSION_ASSERT(shift_amount < kBigitSize);
  ------------------
  |  |   47|  4.71k|    assert(condition)
  ------------------
  |  Branch (743:3): [True: 4.71k, False: 0]
  ------------------
  744|  4.71k|  DOUBLE_CONVERSION_ASSERT(shift_amount >= 0);
  ------------------
  |  |   47|  4.71k|    assert(condition)
  ------------------
  |  Branch (744:3): [True: 4.71k, False: 0]
  ------------------
  745|  4.71k|  Chunk carry = 0;
  746|   132k|  for (int i = 0; i < used_bigits_; ++i) {
  ------------------
  |  Branch (746:19): [True: 127k, False: 4.71k]
  ------------------
  747|   127k|    const Chunk new_carry = RawBigit(i) >> (kBigitSize - shift_amount);
  748|   127k|    RawBigit(i) = ((RawBigit(i) << shift_amount) + carry) & kBigitMask;
  749|   127k|    carry = new_carry;
  750|   127k|  }
  751|  4.71k|  if (carry != 0) {
  ------------------
  |  Branch (751:7): [True: 2.99k, False: 1.72k]
  ------------------
  752|  2.99k|    RawBigit(used_bigits_) = carry;
  753|  2.99k|    used_bigits_++;
  754|  2.99k|  }
  755|  4.71k|}
bignum.cc:_ZN17double_conversionL10ReadUInt64ENS_6VectorIKcEEii:
   80|  4.39k|                           const int digits_to_read) {
   81|  4.39k|  uint64_t result = 0;
   82|  79.1k|  for (int i = from; i < from + digits_to_read; ++i) {
  ------------------
  |  Branch (82:22): [True: 74.7k, False: 4.39k]
  ------------------
   83|  74.7k|    const int digit = buffer[i] - '0';
   84|  74.7k|    DOUBLE_CONVERSION_ASSERT(0 <= digit && digit <= 9);
  ------------------
  |  |   47|  74.7k|    assert(condition)
  ------------------
  |  Branch (84:5): [True: 74.7k, False: 0]
  |  Branch (84:5): [True: 74.7k, False: 0]
  |  Branch (84:5): [True: 74.7k, False: 0]
  ------------------
   85|  74.7k|    result = result * 10 + digit;
   86|  74.7k|  }
   87|  4.39k|  return result;
   88|  4.39k|}

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

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

_ZN17double_conversion5DiyFpC2Ev:
   45|  2.77k|  DiyFp() : f_(0), e_(0) {}
_ZN17double_conversion5DiyFpC2Emi:
   46|  6.22k|  DiyFp(const uint64_t significand, const int32_t exponent) : f_(significand), e_(exponent) {}
_ZN17double_conversion5DiyFp8MultiplyERKS0_:
   68|  2.66k|  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.66k|    const uint64_t kM32 = 0xFFFFFFFFU;
   74|  2.66k|    const uint64_t a = f_ >> 32;
   75|  2.66k|    const uint64_t b = f_ & kM32;
   76|  2.66k|    const uint64_t c = other.f_ >> 32;
   77|  2.66k|    const uint64_t d = other.f_ & kM32;
   78|  2.66k|    const uint64_t ac = a * c;
   79|  2.66k|    const uint64_t bc = b * c;
   80|  2.66k|    const uint64_t ad = a * d;
   81|  2.66k|    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.66k|    const uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32) + (1U << 31);
   85|  2.66k|    e_ += other.e_ + 64;
   86|  2.66k|    f_ = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
   87|  2.66k|  }
_ZN17double_conversion5DiyFp9NormalizeEv:
   96|  2.77k|  void Normalize() {
   97|  2.77k|    DOUBLE_CONVERSION_ASSERT(f_ != 0);
  ------------------
  |  |   47|  2.77k|    assert(condition)
  ------------------
  |  Branch (97:5): [True: 2.77k, False: 0]
  ------------------
   98|  2.77k|    uint64_t significand = f_;
   99|  2.77k|    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.77k|    const uint64_t k10MSBits = DOUBLE_CONVERSION_UINT64_2PART_C(0xFFC00000, 00000000);
  ------------------
  |  |  195|  2.77k|#define DOUBLE_CONVERSION_UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
  ------------------
  104|  5.88k|    while ((significand & k10MSBits) == 0) {
  ------------------
  |  Branch (104:12): [True: 3.10k, False: 2.77k]
  ------------------
  105|  3.10k|      significand <<= 10;
  106|  3.10k|      exponent -= 10;
  107|  3.10k|    }
  108|  7.34k|    while ((significand & kUint64MSB) == 0) {
  ------------------
  |  Branch (108:12): [True: 4.57k, False: 2.77k]
  ------------------
  109|  4.57k|      significand <<= 1;
  110|  4.57k|      exponent--;
  111|  4.57k|    }
  112|  2.77k|    f_ = significand;
  113|  2.77k|    e_ = exponent;
  114|  2.77k|  }
_ZNK17double_conversion5DiyFp1fEv:
  122|  5.30k|  uint64_t f() const { return f_; }
_ZNK17double_conversion5DiyFp1eEv:
  123|  11.3k|  int32_t e() const { return e_; }
_ZN17double_conversion5DiyFp5set_fEm:
  125|    348|  void set_f(uint64_t new_value) { f_ = new_value; }
_ZN17double_conversion5DiyFp5set_eEi:
  126|     60|  void set_e(int32_t new_value) { e_ = new_value; }

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

_ZNK17double_conversion23StringToDoubleConverter14StringToDoubleEPKciPi:
  930|  3.51k|    int* processed_characters_count) const {
  931|  3.51k|  return StringToIeee(buffer, length, true, processed_characters_count);
  932|  3.51k|}
_ZNK17double_conversion23StringToDoubleConverter12StringToIeeeIPKcEEdT_ibPi:
  571|  3.51k|    int* processed_characters_count) const {
  572|  3.51k|  Iterator current = input;
  573|  3.51k|  Iterator end = input + length;
  574|       |
  575|  3.51k|  *processed_characters_count = 0;
  576|       |
  577|  3.51k|  const bool allow_trailing_junk = (flags_ & ALLOW_TRAILING_JUNK) != 0;
  578|  3.51k|  const bool allow_leading_spaces = (flags_ & ALLOW_LEADING_SPACES) != 0;
  579|  3.51k|  const bool allow_trailing_spaces = (flags_ & ALLOW_TRAILING_SPACES) != 0;
  580|  3.51k|  const bool allow_spaces_after_sign = (flags_ & ALLOW_SPACES_AFTER_SIGN) != 0;
  581|  3.51k|  const bool allow_case_insensitivity = (flags_ & ALLOW_CASE_INSENSITIVITY) != 0;
  582|       |
  583|       |  // To make sure that iterator dereferencing is valid the following
  584|       |  // convention is used:
  585|       |  // 1. Each '++current' statement is followed by check for equality to 'end'.
  586|       |  // 2. If AdvanceToNonspace returned false then current == end.
  587|       |  // 3. If 'current' becomes equal to 'end' the function returns or goes to
  588|       |  // 'parsing_done'.
  589|       |  // 4. 'current' is not dereferenced after the 'parsing_done' label.
  590|       |  // 5. Code before 'parsing_done' may rely on 'current != end'.
  591|  3.51k|  if (current == end) return empty_string_value_;
  ------------------
  |  Branch (591:7): [True: 0, False: 3.51k]
  ------------------
  592|       |
  593|  3.51k|  if (allow_leading_spaces || allow_trailing_spaces) {
  ------------------
  |  Branch (593:7): [True: 3.51k, False: 0]
  |  Branch (593:31): [True: 0, False: 0]
  ------------------
  594|  3.51k|    if (!AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (594:9): [True: 11, False: 3.49k]
  ------------------
  595|     11|      *processed_characters_count = static_cast<int>(current - input);
  596|     11|      return empty_string_value_;
  597|     11|    }
  598|  3.49k|    if (!allow_leading_spaces && (input != current)) {
  ------------------
  |  Branch (598:9): [True: 0, False: 3.49k]
  |  Branch (598:34): [True: 0, False: 0]
  ------------------
  599|       |      // No leading spaces allowed, but AdvanceToNonspace moved forward.
  600|      0|      return junk_string_value_;
  601|      0|    }
  602|  3.49k|  }
  603|       |
  604|       |  // Exponent will be adjusted if insignificant digits of the integer part
  605|       |  // or insignificant leading zeros of the fractional part are dropped.
  606|  3.49k|  int exponent = 0;
  607|       |  // Leading fractional zeros and dropped integer digits are both moved into the
  608|       |  // exponent, and both are bounded only by the input length. Saturating the
  609|       |  // accumulation at this magnitude keeps it inside int; any exponent this large
  610|       |  // is far outside the double range, so the clamped result is unchanged.
  611|  3.49k|  const int max_exponent = INT_MAX / 2;
  612|  3.49k|  int significant_digits = 0;
  613|  3.49k|  int insignificant_digits = 0;
  614|  3.49k|  bool nonzero_digit_dropped = false;
  615|       |
  616|  3.49k|  bool sign = false;
  617|       |
  618|  3.49k|  if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (618:7): [True: 11, False: 3.48k]
  |  Branch (618:26): [True: 132, False: 3.35k]
  ------------------
  619|    143|    sign = (*current == '-');
  620|    143|    ++current;
  621|    143|    Iterator next_non_space = current;
  622|       |    // Skip following spaces (if allowed).
  623|    143|    if (!AdvanceToNonspace(&next_non_space, end)) return junk_string_value_;
  ------------------
  |  Branch (623:9): [True: 16, False: 127]
  ------------------
  624|    127|    if (!allow_spaces_after_sign && (current != next_non_space)) {
  ------------------
  |  Branch (624:9): [True: 0, False: 127]
  |  Branch (624:37): [True: 0, False: 0]
  ------------------
  625|      0|      return junk_string_value_;
  626|      0|    }
  627|    127|    current = next_non_space;
  628|    127|  }
  629|       |
  630|  3.48k|  if (infinity_symbol_ != DOUBLE_CONVERSION_NULLPTR) {
  ------------------
  |  |   39|  3.48k|#define DOUBLE_CONVERSION_NULLPTR nullptr
  ------------------
  |  Branch (630:7): [True: 3.48k, False: 0]
  ------------------
  631|  3.48k|    if (ConsumeFirstCharacter(*current, infinity_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (631:9): [True: 31, False: 3.45k]
  ------------------
  632|     31|      if (!ConsumeSubString(&current, end, infinity_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (632:11): [True: 4, False: 27]
  ------------------
  633|      4|        return junk_string_value_;
  634|      4|      }
  635|       |
  636|     27|      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (636:13): [True: 27, False: 0]
  |  Branch (636:38): [True: 0, False: 0]
  |  Branch (636:62): [True: 0, False: 0]
  ------------------
  637|      0|        return junk_string_value_;
  638|      0|      }
  639|     27|      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (639:11): [True: 0, False: 27]
  |  Branch (639:35): [True: 0, False: 0]
  ------------------
  640|      0|        return junk_string_value_;
  641|      0|      }
  642|     27|      if (allow_trailing_spaces) {
  ------------------
  |  Branch (642:11): [True: 27, False: 0]
  ------------------
  643|     27|        AdvanceToNonspace(&current, end);
  644|     27|      }
  645|       |
  646|     27|      *processed_characters_count = static_cast<int>(current - input);
  647|     27|      return sign ? -Double::Infinity() : Double::Infinity();
  ------------------
  |  Branch (647:14): [True: 1, False: 26]
  ------------------
  648|     27|    }
  649|  3.48k|  }
  650|       |
  651|  3.45k|  if (nan_symbol_ != DOUBLE_CONVERSION_NULLPTR) {
  ------------------
  |  |   39|  3.45k|#define DOUBLE_CONVERSION_NULLPTR nullptr
  ------------------
  |  Branch (651:7): [True: 3.45k, False: 0]
  ------------------
  652|  3.45k|    if (ConsumeFirstCharacter(*current, nan_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (652:9): [True: 35, False: 3.41k]
  ------------------
  653|     35|      if (!ConsumeSubString(&current, end, nan_symbol_, allow_case_insensitivity)) {
  ------------------
  |  Branch (653:11): [True: 10, False: 25]
  ------------------
  654|     10|        return junk_string_value_;
  655|     10|      }
  656|       |
  657|     25|      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (657:13): [True: 25, False: 0]
  |  Branch (657:38): [True: 0, False: 0]
  |  Branch (657:62): [True: 0, False: 0]
  ------------------
  658|      0|        return junk_string_value_;
  659|      0|      }
  660|     25|      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (660:11): [True: 0, False: 25]
  |  Branch (660:35): [True: 0, False: 0]
  ------------------
  661|      0|        return junk_string_value_;
  662|      0|      }
  663|     25|      if (allow_trailing_spaces) {
  ------------------
  |  Branch (663:11): [True: 25, False: 0]
  ------------------
  664|     25|        AdvanceToNonspace(&current, end);
  665|     25|      }
  666|       |
  667|     25|      *processed_characters_count = static_cast<int>(current - input);
  668|     25|      return sign ? -Double::NaN() : Double::NaN();
  ------------------
  |  Branch (668:14): [True: 1, False: 24]
  ------------------
  669|     25|    }
  670|  3.45k|  }
  671|       |
  672|  3.41k|  bool leading_zero = false;
  673|  3.41k|  if (*current == '0') {
  ------------------
  |  Branch (673:7): [True: 1.37k, False: 2.04k]
  ------------------
  674|  1.37k|    if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (674:9): [True: 2, False: 1.36k]
  ------------------
  675|      2|      *processed_characters_count = static_cast<int>(current - input);
  676|      2|      return SignedZero(sign);
  677|      2|    }
  678|       |
  679|  1.36k|    leading_zero = true;
  680|       |
  681|       |    // It could be hexadecimal value.
  682|  1.36k|    if (((flags_ & ALLOW_HEX) || (flags_ & ALLOW_HEX_FLOATS)) &&
  ------------------
  |  Branch (682:10): [True: 1.36k, False: 0]
  |  Branch (682:34): [True: 0, False: 0]
  ------------------
  683|  1.36k|        (*current == 'x' || *current == 'X')) {
  ------------------
  |  Branch (683:10): [True: 436, False: 932]
  |  Branch (683:29): [True: 619, False: 313]
  ------------------
  684|  1.05k|      ++current;
  685|       |
  686|  1.05k|      if (current == end) return junk_string_value_;  // "0x"
  ------------------
  |  Branch (686:11): [True: 2, False: 1.05k]
  ------------------
  687|       |
  688|  1.05k|      bool parse_as_hex_float = (flags_ & ALLOW_HEX_FLOATS) &&
  ------------------
  |  Branch (688:33): [True: 1.05k, False: 0]
  ------------------
  689|  1.05k|                IsHexFloatString(current, end, separator_, allow_trailing_junk,
  ------------------
  |  Branch (689:17): [True: 651, False: 402]
  ------------------
  690|  1.05k|                                 allow_trailing_spaces);
  691|       |
  692|       |      // Without ALLOW_HEX the "0x" prefix only introduces a hex-float, so a
  693|       |      // literal that is not one is junk rather than a hex integer.
  694|  1.05k|      if (!parse_as_hex_float &&
  ------------------
  |  Branch (694:11): [True: 402, False: 651]
  ------------------
  695|    402|          (!(flags_ & ALLOW_HEX) || !isDigit(*current, 16))) {
  ------------------
  |  Branch (695:12): [True: 0, False: 402]
  |  Branch (695:37): [True: 91, False: 311]
  ------------------
  696|     91|        return junk_string_value_;
  697|     91|      }
  698|       |
  699|    962|      bool result_is_junk;
  700|    962|      double result = RadixStringToIeee<4>(&current,
  701|    962|                                           end,
  702|    962|                                           sign,
  703|    962|                                           separator_,
  704|    962|                                           parse_as_hex_float,
  705|    962|                                           allow_trailing_junk,
  706|    962|                                           allow_trailing_spaces,
  707|    962|                                           junk_string_value_,
  708|    962|                                           read_as_double,
  709|    962|                                           &result_is_junk);
  710|    962|      if (!result_is_junk) {
  ------------------
  |  Branch (710:11): [True: 962, False: 0]
  ------------------
  711|    962|        if (allow_trailing_spaces) AdvanceToNonspace(&current, end);
  ------------------
  |  Branch (711:13): [True: 962, False: 0]
  ------------------
  712|    962|        *processed_characters_count = static_cast<int>(current - input);
  713|    962|      }
  714|    962|      return result;
  715|  1.05k|    }
  716|       |
  717|       |    // Ignore leading zeros in the integer part.
  718|    693|    while (*current == '0') {
  ------------------
  |  Branch (718:12): [True: 389, False: 304]
  ------------------
  719|    389|      if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (719:11): [True: 9, False: 380]
  ------------------
  720|      9|        *processed_characters_count = static_cast<int>(current - input);
  721|      9|        return SignedZero(sign);
  722|      9|      }
  723|    389|    }
  724|    313|  }
  725|       |
  726|  2.35k|  bool octal = leading_zero && (flags_ & ALLOW_OCTALS) != 0;
  ------------------
  |  Branch (726:16): [True: 304, False: 2.04k]
  |  Branch (726:32): [True: 304, False: 0]
  ------------------
  727|       |
  728|       |  // The longest form of simplified number is: "-<significant digits>.1eXXX\0".
  729|  2.35k|  const int kBufferSize = kMaxSignificantDigits + 10;
  730|  2.35k|  DOUBLE_CONVERSION_STACK_UNINITIALIZED char
  ------------------
  |  |  104|  2.35k|#define DOUBLE_CONVERSION_STACK_UNINITIALIZED __attribute__((uninitialized))
  ------------------
  731|  2.35k|      buffer[kBufferSize];  // NOLINT: size is known at compile time.
  732|  2.35k|  int buffer_pos = 0;
  733|       |
  734|       |  // Copy significant digits of the integer part (if any) to the buffer.
  735|  78.1k|  while (*current >= '0' && *current <= '9') {
  ------------------
  |  Branch (735:10): [True: 77.6k, False: 502]
  |  Branch (735:29): [True: 76.5k, False: 1.04k]
  ------------------
  736|  76.5k|    if (significant_digits < kMaxSignificantDigits) {
  ------------------
  |  Branch (736:9): [True: 76.1k, False: 402]
  ------------------
  737|  76.1k|      DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  76.1k|    assert(condition)
  ------------------
  |  Branch (737:7): [True: 76.1k, False: 0]
  ------------------
  738|  76.1k|      buffer[buffer_pos++] = static_cast<char>(*current);
  739|  76.1k|      significant_digits++;
  740|       |      // Will later check if it's an octal in the buffer.
  741|  76.1k|    } else {
  742|    402|      insignificant_digits++;  // Move the digit into the exponential part.
  743|    402|      nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
  ------------------
  |  Branch (743:31): [True: 195, False: 207]
  |  Branch (743:56): [True: 14, False: 193]
  ------------------
  744|    402|    }
  745|  76.5k|    octal = octal && *current < '8';
  ------------------
  |  Branch (745:13): [True: 8.46k, False: 68.1k]
  |  Branch (745:22): [True: 8.45k, False: 3]
  ------------------
  746|  76.5k|    if (Advance(&current, separator_, 10, end)) goto parsing_done;
  ------------------
  |  Branch (746:9): [True: 806, False: 75.7k]
  ------------------
  747|  76.5k|  }
  748|       |
  749|  1.54k|  if (significant_digits == 0) {
  ------------------
  |  Branch (749:7): [True: 318, False: 1.22k]
  ------------------
  750|    318|    octal = false;
  751|    318|  }
  752|       |
  753|  1.54k|  if (*current == '.') {
  ------------------
  |  Branch (753:7): [True: 407, False: 1.13k]
  ------------------
  754|    407|    if (octal && !allow_trailing_junk) return junk_string_value_;
  ------------------
  |  Branch (754:9): [True: 1, False: 406]
  |  Branch (754:18): [True: 0, False: 1]
  ------------------
  755|    407|    if (octal) goto parsing_done;
  ------------------
  |  Branch (755:9): [True: 1, False: 406]
  ------------------
  756|       |
  757|    406|    if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (757:9): [True: 5, False: 401]
  ------------------
  758|      5|      if (significant_digits == 0 && !leading_zero) {
  ------------------
  |  Branch (758:11): [True: 2, False: 3]
  |  Branch (758:38): [True: 1, False: 1]
  ------------------
  759|      1|        return junk_string_value_;
  760|      4|      } else {
  761|      4|        goto parsing_done;
  762|      4|      }
  763|      5|    }
  764|       |
  765|    401|    if (significant_digits == 0) {
  ------------------
  |  Branch (765:9): [True: 186, False: 215]
  ------------------
  766|       |      // octal = false;
  767|       |      // Integer part consists of 0 or is absent. Significant digits start after
  768|       |      // leading zeros (if any).
  769|  3.23M|      while (*current == '0') {
  ------------------
  |  Branch (769:14): [True: 3.23M, False: 171]
  ------------------
  770|  3.23M|        if (Advance(&current, separator_, 10, end)) {
  ------------------
  |  Branch (770:13): [True: 15, False: 3.23M]
  ------------------
  771|     15|          *processed_characters_count = static_cast<int>(current - input);
  772|     15|          return SignedZero(sign);
  773|     15|        }
  774|       |        // Saturate to avoid underflow on a pathologically long zero run.
  775|  3.23M|        if (exponent > -(max_exponent / 2)) exponent--;  // Move this 0 into the exponent.
  ------------------
  |  Branch (775:13): [True: 3.23M, False: 0]
  ------------------
  776|  3.23M|      }
  777|    186|    }
  778|       |
  779|       |    // There is a fractional part.
  780|       |    // We don't emit a '.', but adjust the exponent instead.
  781|  87.8k|    while (*current >= '0' && *current <= '9') {
  ------------------
  |  Branch (781:12): [True: 87.8k, False: 33]
  |  Branch (781:31): [True: 87.7k, False: 89]
  ------------------
  782|  87.7k|      if (significant_digits < kMaxSignificantDigits) {
  ------------------
  |  Branch (782:11): [True: 70.1k, False: 17.6k]
  ------------------
  783|  70.1k|        DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  70.1k|    assert(condition)
  ------------------
  |  Branch (783:9): [True: 70.1k, False: 0]
  ------------------
  784|  70.1k|        buffer[buffer_pos++] = static_cast<char>(*current);
  785|  70.1k|        significant_digits++;
  786|  70.1k|        if (exponent > -(max_exponent / 2)) exponent--;
  ------------------
  |  Branch (786:13): [True: 70.1k, False: 0]
  ------------------
  787|  70.1k|      } else {
  788|       |        // Ignore insignificant digits in the fractional part.
  789|  17.6k|        nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
  ------------------
  |  Branch (789:33): [True: 6.73k, False: 10.8k]
  |  Branch (789:58): [True: 15, False: 10.8k]
  ------------------
  790|  17.6k|      }
  791|  87.7k|      if (Advance(&current, separator_, 10, end)) goto parsing_done;
  ------------------
  |  Branch (791:11): [True: 264, False: 87.4k]
  ------------------
  792|  87.7k|    }
  793|    386|  }
  794|       |
  795|  1.26k|  if (!leading_zero && exponent == 0 && significant_digits == 0) {
  ------------------
  |  Branch (795:7): [True: 1.18k, False: 79]
  |  Branch (795:24): [True: 1.08k, False: 101]
  |  Branch (795:41): [True: 75, False: 1.00k]
  ------------------
  796|       |    // If leading_zeros is true then the string contains zeros.
  797|       |    // If exponent < 0 then string was [+-]\.0*...
  798|       |    // If significant_digits != 0 the string is not equal to 0.
  799|       |    // Otherwise there are no digits in the string.
  800|     75|    return junk_string_value_;
  801|     75|  }
  802|       |
  803|       |  // Parse exponential part.
  804|  1.18k|  if (*current == 'e' || *current == 'E') {
  ------------------
  |  Branch (804:7): [True: 552, False: 633]
  |  Branch (804:26): [True: 522, False: 111]
  ------------------
  805|  1.07k|    if (octal && !allow_trailing_junk) return junk_string_value_;
  ------------------
  |  Branch (805:9): [True: 1, False: 1.07k]
  |  Branch (805:18): [True: 0, False: 1]
  ------------------
  806|  1.07k|    if (octal) goto parsing_done;
  ------------------
  |  Branch (806:9): [True: 1, False: 1.07k]
  ------------------
  807|  1.07k|    Iterator junk_begin = current;
  808|  1.07k|    ++current;
  809|  1.07k|    if (current == end) {
  ------------------
  |  Branch (809:9): [True: 8, False: 1.06k]
  ------------------
  810|      8|      if (allow_trailing_junk) {
  ------------------
  |  Branch (810:11): [True: 8, False: 0]
  ------------------
  811|      8|        current = junk_begin;
  812|      8|        goto parsing_done;
  813|      8|      } else {
  814|      0|        return junk_string_value_;
  815|      0|      }
  816|      8|    }
  817|  1.06k|    char exponen_sign = '+';
  818|  1.06k|    if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (818:9): [True: 1, False: 1.06k]
  |  Branch (818:28): [True: 392, False: 672]
  ------------------
  819|    393|      exponen_sign = static_cast<char>(*current);
  820|    393|      ++current;
  821|    393|      if (current == end) {
  ------------------
  |  Branch (821:11): [True: 2, False: 391]
  ------------------
  822|      2|        if (allow_trailing_junk) {
  ------------------
  |  Branch (822:13): [True: 2, False: 0]
  ------------------
  823|      2|          current = junk_begin;
  824|      2|          goto parsing_done;
  825|      2|        } else {
  826|      0|          return junk_string_value_;
  827|      0|        }
  828|      2|      }
  829|    393|    }
  830|       |
  831|  1.06k|    if (current == end || *current < '0' || *current > '9') {
  ------------------
  |  Branch (831:9): [True: 0, False: 1.06k]
  |  Branch (831:27): [True: 13, False: 1.05k]
  |  Branch (831:45): [True: 5, False: 1.04k]
  ------------------
  832|     18|      if (allow_trailing_junk) {
  ------------------
  |  Branch (832:11): [True: 18, False: 0]
  ------------------
  833|     18|        current = junk_begin;
  834|     18|        goto parsing_done;
  835|     18|      } else {
  836|      0|        return junk_string_value_;
  837|      0|      }
  838|     18|    }
  839|       |
  840|  1.04k|    DOUBLE_CONVERSION_ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
  ------------------
  |  |   47|  1.04k|    assert(condition)
  ------------------
  |  Branch (840:5): [True: 1.04k, False: 0]
  |  Branch (840:5): [True: 1.04k, False: 0]
  |  Branch (840:5): [True: 1.04k, False: 0]
  ------------------
  841|  1.04k|    int num = 0;
  842|  4.10k|    do {
  843|       |      // Check overflow.
  844|  4.10k|      int digit = *current - '0';
  845|  4.10k|      if (num >= max_exponent / 10
  ------------------
  |  Branch (845:11): [True: 238, False: 3.86k]
  ------------------
  846|    238|          && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
  ------------------
  |  Branch (846:16): [True: 6, False: 232]
  |  Branch (846:44): [True: 3, False: 3]
  ------------------
  847|    235|        num = max_exponent;
  848|  3.86k|      } else {
  849|  3.86k|        num = num * 10 + digit;
  850|  3.86k|      }
  851|  4.10k|      ++current;
  852|  4.10k|    } while (current != end && *current >= '0' && *current <= '9');
  ------------------
  |  Branch (852:14): [True: 3.07k, False: 1.03k]
  |  Branch (852:32): [True: 3.06k, False: 11]
  |  Branch (852:51): [True: 3.05k, False: 4]
  ------------------
  853|       |
  854|  1.04k|    exponent += (exponen_sign == '-' ? -num : num);
  ------------------
  |  Branch (854:18): [True: 391, False: 654]
  ------------------
  855|  1.04k|  }
  856|       |
  857|  1.15k|  if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
  ------------------
  |  Branch (857:9): [True: 1.15k, False: 0]
  |  Branch (857:34): [True: 0, False: 0]
  |  Branch (857:58): [True: 0, False: 0]
  ------------------
  858|      0|    return junk_string_value_;
  859|      0|  }
  860|  1.15k|  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
  ------------------
  |  Branch (860:7): [True: 0, False: 1.15k]
  |  Branch (860:31): [True: 0, False: 0]
  ------------------
  861|      0|    return junk_string_value_;
  862|      0|  }
  863|  1.15k|  if (allow_trailing_spaces) {
  ------------------
  |  Branch (863:7): [True: 1.15k, False: 0]
  ------------------
  864|  1.15k|    AdvanceToNonspace(&current, end);
  865|  1.15k|  }
  866|       |
  867|  2.26k|  parsing_done:
  868|       |  // insignificant_digits counts integer digits dropped past the significand
  869|       |  // limit and is bounded only by the input length, so exponent + it can exceed
  870|       |  // int. Saturate: such a value is out of the double range regardless.
  871|  2.26k|  {
  872|  2.26k|    const int64_t combined =
  873|  2.26k|        static_cast<int64_t>(exponent) + insignificant_digits;
  874|  2.26k|    if (combined > max_exponent) {
  ------------------
  |  Branch (874:9): [True: 1, False: 2.25k]
  ------------------
  875|      1|      exponent = max_exponent;
  876|  2.25k|    } else if (combined < -max_exponent) {
  ------------------
  |  Branch (876:16): [True: 3, False: 2.25k]
  ------------------
  877|      3|      exponent = -max_exponent;
  878|  2.25k|    } else {
  879|  2.25k|      exponent = static_cast<int>(combined);
  880|  2.25k|    }
  881|  2.26k|  }
  882|       |
  883|  2.26k|  if (octal) {
  ------------------
  |  Branch (883:7): [True: 224, False: 2.03k]
  ------------------
  884|    224|    double result;
  885|    224|    bool result_is_junk;
  886|    224|    char* start = buffer;
  887|    224|    result = RadixStringToIeee<3>(&start,
  888|    224|                                  buffer + buffer_pos,
  889|    224|                                  sign,
  890|    224|                                  separator_,
  891|    224|                                  false, // Don't parse as hex_float.
  892|    224|                                  allow_trailing_junk,
  893|    224|                                  allow_trailing_spaces,
  894|    224|                                  junk_string_value_,
  895|    224|                                  read_as_double,
  896|    224|                                  &result_is_junk);
  897|    224|    DOUBLE_CONVERSION_ASSERT(!result_is_junk);
  ------------------
  |  |   47|    224|    assert(condition)
  ------------------
  |  Branch (897:5): [True: 224, False: 0]
  ------------------
  898|    224|    *processed_characters_count = static_cast<int>(current - input);
  899|    224|    return result;
  900|    224|  }
  901|       |
  902|  2.03k|  if (nonzero_digit_dropped) {
  ------------------
  |  Branch (902:7): [True: 29, False: 2.00k]
  ------------------
  903|     29|    buffer[buffer_pos++] = '1';
  904|     29|    exponent--;
  905|     29|  }
  906|       |
  907|  2.03k|  DOUBLE_CONVERSION_ASSERT(buffer_pos < kBufferSize);
  ------------------
  |  |   47|  2.03k|    assert(condition)
  ------------------
  |  Branch (907:3): [True: 2.03k, False: 0]
  ------------------
  908|  2.03k|  buffer[buffer_pos] = '\0';
  909|       |
  910|       |  // Code above ensures there are no leading zeros and the buffer has fewer than
  911|       |  // kMaxSignificantDecimalDigits characters. Trim trailing zeros.
  912|  2.03k|  Vector<const char> chars(buffer, buffer_pos);
  913|  2.03k|  chars = TrimTrailingZeros(chars);
  914|  2.03k|  exponent += buffer_pos - chars.length();
  915|       |
  916|  2.03k|  double converted;
  917|  2.03k|  if (read_as_double) {
  ------------------
  |  Branch (917:7): [True: 2.03k, False: 0]
  ------------------
  918|  2.03k|    converted = StrtodTrimmed(chars, exponent);
  919|  2.03k|  } else {
  920|      0|    converted = StrtofTrimmed(chars, exponent);
  921|      0|  }
  922|  2.03k|  *processed_characters_count = static_cast<int>(current - input);
  923|  2.03k|  return sign? -converted: converted;
  ------------------
  |  Branch (923:10): [True: 3, False: 2.03k]
  ------------------
  924|  2.03k|}
string-to-double.cc:_ZN17double_conversionL17AdvanceToNonspaceIPKcEEbPT_S3_:
  170|  5.82k|static inline bool AdvanceToNonspace(Iterator* current, Iterator end) {
  171|  8.36k|  while (*current != end) {
  ------------------
  |  Branch (171:10): [True: 6.42k, False: 1.94k]
  ------------------
  172|  6.42k|    if (!isWhitespace(**current)) return true;
  ------------------
  |  Branch (172:9): [True: 3.87k, False: 2.54k]
  ------------------
  173|  2.54k|    ++*current;
  174|  2.54k|  }
  175|  1.94k|  return false;
  176|  5.82k|}
string-to-double.cc:_ZN17double_conversionL12isWhitespaceEc:
  154|  6.42k|static bool isWhitespace(char x) {
  155|  6.42k|  return isWhitespace7(x);
  156|  6.42k|}
string-to-double.cc:_ZN17double_conversionL13isWhitespace7Ei:
  140|  6.42k|static bool isWhitespace7(int x) {
  141|  37.3k|  for (int i = 0; i < kWhitespaceTable7Length; i++) {
  ------------------
  |  Branch (141:19): [True: 33.5k, False: 3.87k]
  ------------------
  142|  33.5k|    if (kWhitespaceTable7[i] == x) return true;
  ------------------
  |  Branch (142:9): [True: 2.54k, False: 30.9k]
  ------------------
  143|  33.5k|  }
  144|  3.87k|  return false;
  145|  6.42k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_121ConsumeFirstCharacterIcEEbT_PKcb:
  112|  6.93k|                                         bool case_insensitivity) {
  113|  6.93k|  const uint32_t c = CodeUnit(ch);
  114|  6.93k|  const uint32_t first = CodeUnit(str[0]);
  115|  6.93k|  return case_insensitivity ? ToLower(c) == ToLower(first) : c == first;
  ------------------
  |  Branch (115:10): [True: 6.93k, False: 0]
  ------------------
  116|  6.93k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_18CodeUnitEc:
   57|  14.2k|inline uint32_t CodeUnit(char ch) {
   58|  14.2k|  return static_cast<unsigned char>(ch);
   59|  14.2k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_17ToLowerEj:
   65|  14.2k|inline uint32_t ToLower(uint32_t ch) {
   66|  14.2k|  if (ch > 0x7F) return ch;
  ------------------
  |  Branch (66:7): [True: 53, False: 14.1k]
  ------------------
   67|  14.1k|  static const std::ctype<char>& cType =
   68|  14.1k|      std::use_facet<std::ctype<char> >(std::locale::classic());
   69|  14.1k|  return static_cast<unsigned char>(cType.tolower(static_cast<char>(ch)));
   70|  14.2k|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_116ConsumeSubStringIPKcEEbPT_S4_S3_b:
  100|     66|                             bool allow_case_insensitivity) {
  101|     66|  if (allow_case_insensitivity) {
  ------------------
  |  Branch (101:7): [True: 66, False: 0]
  ------------------
  102|     66|    return ConsumeSubStringImpl(current, end, substring, ToLower);
  103|     66|  } else {
  104|      0|    return ConsumeSubStringImpl(current, end, substring, Pass);
  105|      0|  }
  106|     66|}
string-to-double.cc:_ZN17double_conversion12_GLOBAL__N_120ConsumeSubStringImplIPKcPFjjEEEbPT_S6_S3_T0_:
   80|     66|                                        Converter converter) {
   81|     66|  DOUBLE_CONVERSION_ASSERT(
  ------------------
  |  |   47|     66|    assert(condition)
  ------------------
  |  Branch (81:3): [True: 66, False: 0]
  ------------------
   82|     66|      converter(CodeUnit(**current)) == converter(CodeUnit(*substring)));
   83|    171|  for (substring++; *substring != '\0'; substring++) {
  ------------------
  |  Branch (83:21): [True: 119, False: 52]
  ------------------
   84|    119|    ++*current;
   85|    119|    if (*current == end ||
  ------------------
  |  Branch (85:9): [True: 4, False: 115]
  ------------------
   86|    115|        converter(CodeUnit(**current)) != converter(CodeUnit(*substring))) {
  ------------------
  |  Branch (86:9): [True: 10, False: 105]
  ------------------
   87|     14|      return false;
   88|     14|    }
   89|    119|  }
   90|     52|  ++*current;
   91|     52|  return true;
   92|     66|}
string-to-double.cc:_ZN17double_conversionL7AdvanceIPKcEEbPT_tiRS3_:
  221|  6.58M|static bool Advance (Iterator* it, uc16 separator, int base, Iterator& end) {
  222|  6.58M|  if (separator == StringToDoubleConverter::kNoSeparator) {
  ------------------
  |  Branch (222:7): [True: 6.58M, False: 0]
  ------------------
  223|  6.58M|    ++(*it);
  224|  6.58M|    return *it == end;
  225|  6.58M|  }
  226|      0|  if (!isDigit(**it, base)) {
  ------------------
  |  Branch (226:7): [True: 0, False: 0]
  ------------------
  227|      0|    ++(*it);
  228|      0|    return *it == end;
  229|      0|  }
  230|      0|  ++(*it);
  231|      0|  if (*it == end) return true;
  ------------------
  |  Branch (231:7): [True: 0, False: 0]
  ------------------
  232|      0|  if (*it + 1 == end) return false;
  ------------------
  |  Branch (232:7): [True: 0, False: 0]
  ------------------
  233|      0|  if (**it == separator && isDigit(*(*it + 1), base)) {
  ------------------
  |  Branch (233:7): [True: 0, False: 0]
  |  Branch (233:28): [True: 0, False: 0]
  ------------------
  234|      0|    ++(*it);
  235|      0|  }
  236|      0|  return *it == end;
  237|      0|}
string-to-double.cc:_ZN17double_conversionL10SignedZeroEb:
  186|    121|static double SignedZero(bool sign) {
  187|    121|  return sign ? -0.0 : 0.0;
  ------------------
  |  Branch (187:10): [True: 1, False: 120]
  ------------------
  188|    121|}
string-to-double.cc:_ZN17double_conversionL16IsHexFloatStringIPKcEEbT_S3_tbb:
  251|  1.70k|                             bool allow_trailing_spaces) {
  252|  1.70k|  DOUBLE_CONVERSION_ASSERT(start != end);
  ------------------
  |  |   47|  1.70k|    assert(condition)
  ------------------
  |  Branch (252:3): [True: 1.70k, False: 0]
  ------------------
  253|       |
  254|  1.70k|  Iterator current = start;
  255|       |
  256|  1.70k|  bool saw_digit = false;
  257|  13.8k|  while (isDigit(*current, 16)) {
  ------------------
  |  Branch (257:10): [True: 12.3k, False: 1.50k]
  ------------------
  258|  12.3k|    saw_digit = true;
  259|  12.3k|    if (Advance(&current, separator, 16, end)) return false;
  ------------------
  |  Branch (259:9): [True: 198, False: 12.1k]
  ------------------
  260|  12.3k|  }
  261|  1.50k|  if (*current == '.') {
  ------------------
  |  Branch (261:7): [True: 140, False: 1.36k]
  ------------------
  262|    140|    if (Advance(&current, separator, 16, end)) return false;
  ------------------
  |  Branch (262:9): [True: 3, False: 137]
  ------------------
  263|  2.10M|    while (isDigit(*current, 16)) {
  ------------------
  |  Branch (263:12): [True: 2.10M, False: 119]
  ------------------
  264|  2.10M|      saw_digit = true;
  265|  2.10M|      if (Advance(&current, separator, 16, end)) return false;
  ------------------
  |  Branch (265:11): [True: 18, False: 2.10M]
  ------------------
  266|  2.10M|    }
  267|    137|  }
  268|  1.48k|  if (!saw_digit) return false;
  ------------------
  |  Branch (268:7): [True: 69, False: 1.41k]
  ------------------
  269|  1.41k|  if (*current != 'p' && *current != 'P') return false;
  ------------------
  |  Branch (269:7): [True: 453, False: 963]
  |  Branch (269:26): [True: 85, False: 368]
  ------------------
  270|       |  // The separator is only allowed between significand digits, not in the
  271|       |  // exponent, so advance through the exponent with no separator.
  272|  1.33k|  const uc16 kNoSeparator = StringToDoubleConverter::kNoSeparator;
  273|  1.33k|  if (Advance(&current, kNoSeparator, 16, end)) return false;
  ------------------
  |  Branch (273:7): [True: 7, False: 1.32k]
  ------------------
  274|  1.32k|  if (*current == '+' || *current == '-') {
  ------------------
  |  Branch (274:7): [True: 3, False: 1.32k]
  |  Branch (274:26): [True: 708, False: 613]
  ------------------
  275|    711|    if (Advance(&current, kNoSeparator, 16, end)) return false;
  ------------------
  |  Branch (275:9): [True: 2, False: 709]
  ------------------
  276|    711|  }
  277|  1.32k|  if (!isDigit(*current, 10)) return false;
  ------------------
  |  Branch (277:7): [True: 20, False: 1.30k]
  ------------------
  278|  1.30k|  if (Advance(&current, kNoSeparator, 16, end)) return true;
  ------------------
  |  Branch (278:7): [True: 244, False: 1.05k]
  ------------------
  279|  6.18k|  while (isDigit(*current, 10)) {
  ------------------
  |  Branch (279:10): [True: 6.15k, False: 34]
  ------------------
  280|  6.15k|    if (Advance(&current, kNoSeparator, 16, end)) return true;
  ------------------
  |  Branch (280:9): [True: 1.02k, False: 5.12k]
  ------------------
  281|  6.15k|  }
  282|       |  // Trailing whitespace is junk unless ALLOW_TRAILING_SPACES is set, as it is
  283|       |  // for decimal numbers.
  284|     34|  if (allow_trailing_junk) return true;
  ------------------
  |  Branch (284:7): [True: 34, False: 0]
  ------------------
  285|      0|  return allow_trailing_spaces && !AdvanceToNonspace(&current, end);
  ------------------
  |  Branch (285:10): [True: 0, False: 0]
  |  Branch (285:35): [True: 0, False: 0]
  ------------------
  286|     34|}
string-to-double.cc:_ZN17double_conversionL7isDigitEii:
  179|  3.18M|static bool isDigit(int x, int radix) {
  180|  3.18M|  return (x >= '0' && x <= '9' && x < '0' + radix)
  ------------------
  |  Branch (180:11): [True: 3.18M, False: 342]
  |  Branch (180:23): [True: 3.17M, False: 10.2k]
  |  Branch (180:35): [True: 3.17M, False: 0]
  ------------------
  181|  10.5k|      || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
  ------------------
  |  Branch (181:11): [True: 10.5k, False: 54]
  |  Branch (181:25): [True: 5.32k, False: 5.17k]
  |  Branch (181:37): [True: 4.13k, False: 1.19k]
  ------------------
  182|  6.42k|      || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
  ------------------
  |  Branch (182:11): [True: 6.37k, False: 54]
  |  Branch (182:25): [True: 6.03k, False: 338]
  |  Branch (182:37): [True: 4.36k, False: 1.66k]
  ------------------
  183|  3.18M|}
string-to-double.cc:_ZN17double_conversionL17RadixStringToIeeeILi4EPKcEEdPT0_S3_btbbbdbPb:
  303|    962|                                bool* result_is_junk) {
  304|    962|  DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    962|    assert(condition)
  ------------------
  |  Branch (304:3): [True: 962, False: 0]
  ------------------
  305|    962|  DOUBLE_CONVERSION_ASSERT(!parse_as_hex_float ||
  ------------------
  |  |   47|    962|    assert(condition)
  ------------------
  |  Branch (305:3): [True: 311, False: 651]
  |  Branch (305:3): [True: 651, False: 0]
  |  Branch (305:3): [True: 962, False: 0]
  ------------------
  306|    962|      IsHexFloatString(*current, end, separator, allow_trailing_junk,
  307|    962|                       allow_trailing_spaces));
  308|       |
  309|    962|  const int kDoubleSize = Double::kSignificandSize;
  310|    962|  const int kSingleSize = Single::kSignificandSize;
  311|       |  // A hex-float is formed here as a double and rounded to float by the caller
  312|       |  // (StringToFloat casts the result). Rounding the significand to single
  313|       |  // precision here would double-round both subnormal floats and floats whose
  314|       |  // exact significand exceeds 53 bits, so keep the full double significand and
  315|       |  // round it to odd, which makes that final single-precision cast correct.
  316|    962|  const bool round_hex_float_to_single = parse_as_hex_float && !read_as_double;
  ------------------
  |  Branch (316:42): [True: 651, False: 311]
  |  Branch (316:64): [True: 0, False: 651]
  ------------------
  317|    962|  const int kSignificandSize =
  318|    962|      (read_as_double || parse_as_hex_float) ? kDoubleSize : kSingleSize;
  ------------------
  |  Branch (318:8): [True: 962, False: 0]
  |  Branch (318:26): [True: 0, False: 0]
  ------------------
  319|       |
  320|    962|  *result_is_junk = true;
  321|       |
  322|    962|  int64_t number = 0;
  323|       |  // The exponent moves by radix_log_2 per input character, so 64 bits hold it
  324|       |  // exactly for any input length. Clamping it into the int range while reading
  325|       |  // the significand instead would lose magnitude that the written exponent is
  326|       |  // allowed to cancel.
  327|    962|  int64_t unclamped_exponent = 0;
  328|    962|  const int max_exponent = INT_MAX / 2;
  329|       |  // A hex-float parsed as a double has its significand rounded to
  330|       |  // kSignificandSize bits below. That is the single correct rounding for a normal
  331|       |  // result, but a subnormal result is rounded again by ldexp into the narrower
  332|       |  // subnormal grid, so rounding to nearest here double-rounds. Retain the exact
  333|       |  // significand, its dropped-bit count and a sticky flag so a subnormal result can
  334|       |  // be rounded once, directly onto the 2^-1074 grid.
  335|    962|  int64_t hex_exact_significand = 0;
  336|    962|  int hex_dropped_bits = 0;
  337|    962|  bool hex_significand_sticky = false;
  338|    962|  bool hex_significand_overflowed = false;
  339|    962|  const int radix = (1 << radix_log_2);
  340|       |  // Whether we have encountered a '.' and are parsing the decimal digits.
  341|       |  // Only relevant if parse_as_hex_float is true.
  342|    962|  bool post_decimal = false;
  343|       |
  344|       |  // Skip leading 0s.
  345|  1.39k|  while (**current == '0') {
  ------------------
  |  Branch (345:10): [True: 444, False: 954]
  ------------------
  346|    444|    if (Advance(current, separator, radix, end)) {
  ------------------
  |  Branch (346:9): [True: 8, False: 436]
  ------------------
  347|      8|      *result_is_junk = false;
  348|      8|      return SignedZero(sign);
  349|      8|    }
  350|    444|  }
  351|       |
  352|  8.00k|  while (true) {
  ------------------
  |  Branch (352:10): [True: 8.00k, Folded]
  ------------------
  353|  8.00k|    int digit;
  354|  8.00k|    if (IsDecimalDigitForRadix(**current, radix)) {
  ------------------
  |  Branch (354:9): [True: 3.37k, False: 4.62k]
  ------------------
  355|  3.37k|      digit = static_cast<char>(**current) - '0';
  356|  3.37k|      if (post_decimal) unclamped_exponent -= radix_log_2;
  ------------------
  |  Branch (356:11): [True: 1.19k, False: 2.17k]
  ------------------
  357|  4.62k|    } else if (IsCharacterDigitForRadix(**current, radix, 'a')) {
  ------------------
  |  Branch (357:16): [True: 1.97k, False: 2.64k]
  ------------------
  358|  1.97k|      digit = static_cast<char>(**current) - 'a' + 10;
  359|  1.97k|      if (post_decimal) unclamped_exponent -= radix_log_2;
  ------------------
  |  Branch (359:11): [True: 89, False: 1.89k]
  ------------------
  360|  2.64k|    } else if (IsCharacterDigitForRadix(**current, radix, 'A')) {
  ------------------
  |  Branch (360:16): [True: 2.13k, False: 518]
  ------------------
  361|  2.13k|      digit = static_cast<char>(**current) - 'A' + 10;
  362|  2.13k|      if (post_decimal) unclamped_exponent -= radix_log_2;
  ------------------
  |  Branch (362:11): [True: 74, False: 2.05k]
  ------------------
  363|  2.13k|    } else if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (363:16): [True: 433, False: 85]
  |  Branch (363:38): [True: 41, False: 392]
  ------------------
  364|     41|      post_decimal = true;
  365|     41|      Advance(current, separator, radix, end);
  366|     41|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|     41|    assert(condition)
  ------------------
  |  Branch (366:7): [True: 41, False: 0]
  ------------------
  367|     41|      continue;
  368|    477|    } else if (parse_as_hex_float && (**current == 'p' || **current == 'P')) {
  ------------------
  |  Branch (368:16): [True: 392, False: 85]
  |  Branch (368:39): [True: 274, False: 118]
  |  Branch (368:59): [True: 118, False: 0]
  ------------------
  369|    392|      break;
  370|    392|    } else {
  371|       |      // Trailing whitespace is junk unless ALLOW_TRAILING_SPACES is set, as it
  372|       |      // is for decimal numbers.
  373|     85|      if (allow_trailing_junk ||
  ------------------
  |  Branch (373:11): [True: 85, False: 0]
  ------------------
  374|     85|          (allow_trailing_spaces && !AdvanceToNonspace(current, end))) {
  ------------------
  |  Branch (374:12): [True: 0, False: 0]
  |  Branch (374:37): [True: 0, False: 0]
  ------------------
  375|     85|        break;
  376|     85|      } else {
  377|      0|        return junk_string_value;
  378|      0|      }
  379|     85|    }
  380|       |
  381|  7.48k|    number = number * radix + digit;
  382|  7.48k|    int overflow = static_cast<int>(number >> kSignificandSize);
  383|  7.48k|    if (overflow != 0) {
  ------------------
  |  Branch (383:9): [True: 350, False: 7.13k]
  ------------------
  384|       |      // Overflow occurred. Need to determine which direction to round the
  385|       |      // result.
  386|    350|      int overflow_bits_count = 1;
  387|    953|      while (overflow > 1) {
  ------------------
  |  Branch (387:14): [True: 603, False: 350]
  ------------------
  388|    603|        overflow_bits_count++;
  389|    603|        overflow >>= 1;
  390|    603|      }
  391|       |
  392|    350|      int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
  393|    350|      int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
  394|    350|      if (parse_as_hex_float && read_as_double) {
  ------------------
  |  Branch (394:11): [True: 259, False: 91]
  |  Branch (394:33): [True: 259, False: 0]
  ------------------
  395|    259|        hex_significand_overflowed = true;
  396|    259|        hex_exact_significand = number;
  397|    259|        hex_dropped_bits = overflow_bits_count;
  398|    259|      }
  399|    350|      number >>= overflow_bits_count;
  400|    350|      unclamped_exponent += overflow_bits_count;
  401|       |
  402|    350|      bool zero_tail = true;
  403|  1.04M|      for (;;) {
  404|  1.04M|        if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (404:13): [True: 63, False: 1.04M]
  ------------------
  405|  1.04M|        if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (405:13): [True: 1.04M, False: 1.15k]
  |  Branch (405:35): [True: 1, False: 1.04M]
  ------------------
  406|       |          // Just run over the '.'. We are just trying to see whether there is
  407|       |          // a non-zero digit somewhere.
  408|      1|          Advance(current, separator, radix, end);
  409|      1|          DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      1|    assert(condition)
  ------------------
  |  Branch (409:11): [True: 1, False: 0]
  ------------------
  410|      1|          post_decimal = true;
  411|      1|        }
  412|  1.04M|        if (!isDigit(**current, radix)) break;
  ------------------
  |  Branch (412:13): [True: 287, False: 1.04M]
  ------------------
  413|  1.04M|        zero_tail = zero_tail && **current == '0';
  ------------------
  |  Branch (413:21): [True: 124k, False: 924k]
  |  Branch (413:34): [True: 124k, False: 73]
  ------------------
  414|  1.04M|        if (!post_decimal) unclamped_exponent += radix_log_2;
  ------------------
  |  Branch (414:13): [True: 1.46k, False: 1.04M]
  ------------------
  415|  1.04M|      }
  416|       |
  417|    350|      if (!parse_as_hex_float && !allow_trailing_junk) {
  ------------------
  |  Branch (417:11): [True: 91, False: 259]
  |  Branch (417:34): [True: 0, False: 91]
  ------------------
  418|      0|        if (allow_trailing_spaces ? AdvanceToNonspace(current, end)
  ------------------
  |  Branch (418:13): [True: 0, False: 0]
  |  Branch (418:13): [True: 0, False: 0]
  ------------------
  419|      0|                                  : *current != end) {
  420|      0|          return junk_string_value;
  421|      0|        }
  422|      0|      }
  423|       |
  424|    350|      if (round_hex_float_to_single) {
  ------------------
  |  Branch (424:11): [True: 0, False: 350]
  ------------------
  425|       |        // Round the significand to odd: set the lowest kept bit whenever any
  426|       |        // bit was dropped. The caller rounds this double to float; rounding to
  427|       |        // nearest here would double-round, but round-to-odd leaves that final
  428|       |        // single rounding correct for normal and subnormal results alike.
  429|      0|        if (dropped_bits != 0 || !zero_tail) {
  ------------------
  |  Branch (429:13): [True: 0, False: 0]
  |  Branch (429:34): [True: 0, False: 0]
  ------------------
  430|      0|          number |= 1;
  431|      0|        }
  432|    350|      } else {
  433|    350|        if (hex_significand_overflowed) {
  ------------------
  |  Branch (433:13): [True: 259, False: 91]
  ------------------
  434|    259|          hex_significand_sticky = !zero_tail;
  435|    259|        }
  436|    350|        int middle_value = (1 << (overflow_bits_count - 1));
  437|    350|        if (dropped_bits > middle_value) {
  ------------------
  |  Branch (437:13): [True: 154, False: 196]
  ------------------
  438|    154|          number++;  // Rounding up.
  439|    196|        } else if (dropped_bits == middle_value) {
  ------------------
  |  Branch (439:20): [True: 51, False: 145]
  ------------------
  440|       |          // Rounding to even to consistency with decimals: half-way case rounds
  441|       |          // up if significant part is odd and down otherwise.
  442|     51|          if ((number & 1) != 0 || !zero_tail) {
  ------------------
  |  Branch (442:15): [True: 24, False: 27]
  |  Branch (442:36): [True: 4, False: 23]
  ------------------
  443|     28|            number++;  // Rounding up.
  444|     28|          }
  445|     51|        }
  446|       |
  447|       |        // Rounding up may cause overflow.
  448|    350|        if ((number & ((int64_t)1 << kSignificandSize)) != 0) {
  ------------------
  |  Branch (448:13): [True: 9, False: 341]
  ------------------
  449|      9|          unclamped_exponent++;
  450|      9|          number >>= 1;
  451|       |          // The exact significand keeps its scale, so it now sits one more bit
  452|       |          // below exponent.
  453|      9|          hex_dropped_bits++;
  454|      9|        }
  455|    350|      }
  456|    350|      break;
  457|    350|    }
  458|  7.13k|    if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (458:9): [True: 127, False: 7.00k]
  ------------------
  459|  7.13k|  }
  460|       |
  461|    954|  DOUBLE_CONVERSION_ASSERT(number < ((int64_t)1 << kSignificandSize));
  ------------------
  |  |   47|    954|    assert(condition)
  ------------------
  |  Branch (461:3): [True: 954, False: 0]
  ------------------
  462|    954|  DOUBLE_CONVERSION_ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
  ------------------
  |  |   47|    954|    assert(condition)
  ------------------
  |  Branch (462:3): [True: 954, False: 0]
  ------------------
  463|       |
  464|    954|  *result_is_junk = false;
  465|       |
  466|    954|  if (parse_as_hex_float) {
  ------------------
  |  Branch (466:7): [True: 651, False: 303]
  ------------------
  467|    651|    DOUBLE_CONVERSION_ASSERT(**current == 'p' || **current == 'P');
  ------------------
  |  |   47|    651|    assert(condition)
  ------------------
  |  Branch (467:5): [True: 471, False: 180]
  |  Branch (467:5): [True: 180, False: 0]
  |  Branch (467:5): [True: 651, False: 0]
  ------------------
  468|       |    // The separator is only allowed between significand digits, not in the
  469|       |    // exponent, so advance through the exponent with no separator. This must
  470|       |    // match IsHexFloatString, which validated the string the same way.
  471|    651|    const uc16 kNoSeparator = StringToDoubleConverter::kNoSeparator;
  472|    651|    Advance(current, kNoSeparator, radix, end);
  473|    651|    DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    651|    assert(condition)
  ------------------
  |  Branch (473:5): [True: 651, False: 0]
  ------------------
  474|    651|    bool is_negative = false;
  475|    651|    if (**current == '+') {
  ------------------
  |  Branch (475:9): [True: 1, False: 650]
  ------------------
  476|      1|      Advance(current, kNoSeparator, radix, end);
  477|      1|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      1|    assert(condition)
  ------------------
  |  Branch (477:7): [True: 1, False: 0]
  ------------------
  478|    650|    } else if (**current == '-') {
  ------------------
  |  Branch (478:16): [True: 353, False: 297]
  ------------------
  479|    353|      is_negative = true;
  480|    353|      Advance(current, kNoSeparator, radix, end);
  481|    353|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    353|    assert(condition)
  ------------------
  |  Branch (481:7): [True: 353, False: 0]
  ------------------
  482|    353|    }
  483|       |    // The written exponent is bounded only by the input length, so it still
  484|       |    // has to saturate, but stopping short of a written digit would change the
  485|       |    // result: the significand's exponent can cancel a written exponent of any
  486|       |    // size. Saturate past twice the largest magnitude that exponent can reach
  487|       |    // (radix_log_2 per character, over a length that is an int), so that a
  488|       |    // saturated written exponent always outweighs the significand and the sum
  489|       |    // keeps the sign of the exponent that was written.
  490|    651|    const int64_t max_written_exponent =
  491|    651|        2 * static_cast<int64_t>(radix_log_2) * INT_MAX;
  492|    651|    int64_t written_exponent = 0;
  493|  3.74k|    while (IsDecimalDigitForRadix(**current, 10)) {
  ------------------
  |  Branch (493:12): [True: 3.72k, False: 17]
  ------------------
  494|  3.72k|      written_exponent = 10 * written_exponent + (**current - '0');
  495|  3.72k|      if (written_exponent > max_written_exponent) {
  ------------------
  |  Branch (495:11): [True: 294, False: 3.43k]
  ------------------
  496|    294|        written_exponent = max_written_exponent;
  497|    294|      }
  498|  3.72k|      if (Advance(current, kNoSeparator, radix, end)) break;
  ------------------
  |  Branch (498:11): [True: 634, False: 3.09k]
  ------------------
  499|  3.72k|    }
  500|    651|    if (is_negative) written_exponent = -written_exponent;
  ------------------
  |  Branch (500:9): [True: 353, False: 298]
  ------------------
  501|    651|    unclamped_exponent += written_exponent;
  502|    651|  }
  503|       |
  504|       |  // Both parts were accumulated without loss, so clamping their sum now cannot
  505|       |  // cancel either of them. Below, an exponent this far out of range only has
  506|       |  // to keep its sign.
  507|    954|  int exponent;
  508|    954|  if (unclamped_exponent > max_exponent) {
  ------------------
  |  Branch (508:7): [True: 44, False: 910]
  ------------------
  509|     44|    exponent = max_exponent;
  510|    910|  } else if (unclamped_exponent < -max_exponent) {
  ------------------
  |  Branch (510:14): [True: 39, False: 871]
  ------------------
  511|     39|    exponent = -max_exponent;
  512|    871|  } else {
  513|    871|    exponent = static_cast<int>(unclamped_exponent);
  514|    871|  }
  515|       |
  516|    954|  if (exponent == 0 || number == 0) {
  ------------------
  |  Branch (516:7): [True: 220, False: 734]
  |  Branch (516:24): [True: 40, False: 694]
  ------------------
  517|    260|    if (sign) {
  ------------------
  |  Branch (517:9): [True: 53, False: 207]
  ------------------
  518|     53|      if (number == 0) return -0.0;
  ------------------
  |  Branch (518:11): [True: 1, False: 52]
  ------------------
  519|     52|      number = -number;
  520|     52|    }
  521|    259|    return static_cast<double>(number);
  522|    260|  }
  523|       |
  524|    694|  DOUBLE_CONVERSION_ASSERT(number != 0);
  ------------------
  |  |   47|    694|    assert(condition)
  ------------------
  |  Branch (524:3): [True: 694, False: 0]
  ------------------
  525|    694|  if (exponent > 100 * Double::kMaxExponent) {
  ------------------
  |  Branch (525:7): [True: 82, False: 612]
  ------------------
  526|     82|    return sign ? -Double::Infinity() : Double::Infinity();
  ------------------
  |  Branch (526:12): [True: 1, False: 81]
  ------------------
  527|     82|  }
  528|    612|  if (exponent < -100 * Double::kMaxExponent) {
  ------------------
  |  Branch (528:7): [True: 87, False: 525]
  ------------------
  529|     87|    return SignedZero(sign);
  530|     87|  }
  531|       |  // number is an exact integer below 2^kSignificandSize, so number * 2^exponent
  532|       |  // can be formed directly. Double(DiyFp(number, exponent)) would instead assume
  533|       |  // a normalized significand: a hex-float like "0x1p1000" or "0x2p-1075" reaches
  534|       |  // here with a small number and a large exponent, which DiyFpToUint64 then reads
  535|       |  // as an overflow (infinity) or underflow (zero) rather than the finite result.
  536|    525|  double result = ldexp(static_cast<double>(number), exponent);
  537|    525|  if (hex_significand_overflowed) {
  ------------------
  |  Branch (537:7): [True: 259, False: 266]
  ------------------
  538|       |    // Whether the result is subnormal is decided from the exact significand
  539|       |    // and its scale, not from result: result has already been rounded twice,
  540|       |    // and the second rounding can land it on zero or on the smallest normal.
  541|    259|    const int kDenormalExponent = -1074;
  542|    259|    int scale = exponent - hex_dropped_bits;  // binary scale of the exact LSB
  543|    259|    int drop = kDenormalExponent - scale;     // low bits to discard for the grid
  544|       |    // drop <= 0 is always a normal result. For drop >= 63 the exact value is
  545|       |    // below half the smallest subnormal, where the zero from ldexp is correct.
  546|    259|    if (drop > 0 && drop < 63) {
  ------------------
  |  Branch (546:9): [True: 200, False: 59]
  |  Branch (546:21): [True: 181, False: 19]
  ------------------
  547|    181|      int64_t high = hex_exact_significand >> drop;
  548|       |      // The smallest normal is 2^52 on the grid, and the exact value is below
  549|       |      // it exactly when high is.
  550|    181|      if (high < static_cast<int64_t>(Double::kHiddenBit)) {
  ------------------
  |  Branch (550:11): [True: 176, False: 5]
  ------------------
  551|       |        // Subnormal. Round the exact significand once, straight onto the
  552|       |        // 2^-1074 subnormal grid, instead of the round-to-nearest-then-ldexp
  553|       |        // double rounding.
  554|    176|        int64_t low = hex_exact_significand & (((int64_t)1 << drop) - 1);
  555|    176|        int64_t half = (int64_t)1 << (drop - 1);
  556|    176|        bool round_up = low > half ||
  ------------------
  |  Branch (556:25): [True: 90, False: 86]
  ------------------
  557|     86|            (low == half && (hex_significand_sticky || (high & 1) != 0));
  ------------------
  |  Branch (557:14): [True: 12, False: 74]
  |  Branch (557:30): [True: 1, False: 11]
  |  Branch (557:56): [True: 3, False: 8]
  ------------------
  558|    176|        if (round_up) high++;
  ------------------
  |  Branch (558:13): [True: 94, False: 82]
  ------------------
  559|    176|        result = ldexp(static_cast<double>(high), kDenormalExponent);
  560|    176|      }
  561|    181|    }
  562|    259|  }
  563|    525|  return sign ? -result : result;
  ------------------
  |  Branch (563:10): [True: 1, False: 524]
  ------------------
  564|    612|}
string-to-double.cc:_ZN17double_conversionL22IsDecimalDigitForRadixEii:
  204|  14.7k|static bool inline IsDecimalDigitForRadix(int c, int radix) {
  205|  14.7k|  return '0' <= c && c <= '9' && (c - '0') < radix;
  ------------------
  |  Branch (205:10): [True: 14.6k, False: 94]
  |  Branch (205:22): [True: 10.1k, False: 4.55k]
  |  Branch (205:34): [True: 10.1k, False: 0]
  ------------------
  206|  14.7k|}
string-to-double.cc:_ZN17double_conversionL24IsCharacterDigitForRadixEiic:
  215|  7.27k|static bool IsCharacterDigitForRadix(int c, int radix, char a_character) {
  216|  7.27k|  return radix > 10 && c >= a_character && c < a_character + radix - 10;
  ------------------
  |  Branch (216:10): [True: 7.27k, False: 0]
  |  Branch (216:24): [True: 4.84k, False: 2.43k]
  |  Branch (216:44): [True: 4.11k, False: 732]
  ------------------
  217|  7.27k|}
string-to-double.cc:_ZN17double_conversionL17RadixStringToIeeeILi3EPcEEdPT0_S2_btbbbdbPb:
  303|    224|                                bool* result_is_junk) {
  304|    224|  DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|    224|    assert(condition)
  ------------------
  |  Branch (304:3): [True: 224, False: 0]
  ------------------
  305|    224|  DOUBLE_CONVERSION_ASSERT(!parse_as_hex_float ||
  ------------------
  |  |   47|    224|    assert(condition)
  ------------------
  |  Branch (305:3): [True: 224, False: 0]
  |  Branch (305:3): [True: 0, False: 0]
  |  Branch (305:3): [True: 224, False: 0]
  ------------------
  306|    224|      IsHexFloatString(*current, end, separator, allow_trailing_junk,
  307|    224|                       allow_trailing_spaces));
  308|       |
  309|    224|  const int kDoubleSize = Double::kSignificandSize;
  310|    224|  const int kSingleSize = Single::kSignificandSize;
  311|       |  // A hex-float is formed here as a double and rounded to float by the caller
  312|       |  // (StringToFloat casts the result). Rounding the significand to single
  313|       |  // precision here would double-round both subnormal floats and floats whose
  314|       |  // exact significand exceeds 53 bits, so keep the full double significand and
  315|       |  // round it to odd, which makes that final single-precision cast correct.
  316|    224|  const bool round_hex_float_to_single = parse_as_hex_float && !read_as_double;
  ------------------
  |  Branch (316:42): [True: 0, False: 224]
  |  Branch (316:64): [True: 0, False: 0]
  ------------------
  317|    224|  const int kSignificandSize =
  318|    224|      (read_as_double || parse_as_hex_float) ? kDoubleSize : kSingleSize;
  ------------------
  |  Branch (318:8): [True: 224, False: 0]
  |  Branch (318:26): [True: 0, False: 0]
  ------------------
  319|       |
  320|    224|  *result_is_junk = true;
  321|       |
  322|    224|  int64_t number = 0;
  323|       |  // The exponent moves by radix_log_2 per input character, so 64 bits hold it
  324|       |  // exactly for any input length. Clamping it into the int range while reading
  325|       |  // the significand instead would lose magnitude that the written exponent is
  326|       |  // allowed to cancel.
  327|    224|  int64_t unclamped_exponent = 0;
  328|    224|  const int max_exponent = INT_MAX / 2;
  329|       |  // A hex-float parsed as a double has its significand rounded to
  330|       |  // kSignificandSize bits below. That is the single correct rounding for a normal
  331|       |  // result, but a subnormal result is rounded again by ldexp into the narrower
  332|       |  // subnormal grid, so rounding to nearest here double-rounds. Retain the exact
  333|       |  // significand, its dropped-bit count and a sticky flag so a subnormal result can
  334|       |  // be rounded once, directly onto the 2^-1074 grid.
  335|    224|  int64_t hex_exact_significand = 0;
  336|    224|  int hex_dropped_bits = 0;
  337|    224|  bool hex_significand_sticky = false;
  338|    224|  bool hex_significand_overflowed = false;
  339|    224|  const int radix = (1 << radix_log_2);
  340|       |  // Whether we have encountered a '.' and are parsing the decimal digits.
  341|       |  // Only relevant if parse_as_hex_float is true.
  342|    224|  bool post_decimal = false;
  343|       |
  344|       |  // Skip leading 0s.
  345|    224|  while (**current == '0') {
  ------------------
  |  Branch (345:10): [True: 0, False: 224]
  ------------------
  346|      0|    if (Advance(current, separator, radix, end)) {
  ------------------
  |  Branch (346:9): [True: 0, False: 0]
  ------------------
  347|      0|      *result_is_junk = false;
  348|      0|      return SignedZero(sign);
  349|      0|    }
  350|      0|  }
  351|       |
  352|  3.01k|  while (true) {
  ------------------
  |  Branch (352:10): [True: 3.01k, Folded]
  ------------------
  353|  3.01k|    int digit;
  354|  3.01k|    if (IsDecimalDigitForRadix(**current, radix)) {
  ------------------
  |  Branch (354:9): [True: 3.01k, False: 0]
  ------------------
  355|  3.01k|      digit = static_cast<char>(**current) - '0';
  356|  3.01k|      if (post_decimal) unclamped_exponent -= radix_log_2;
  ------------------
  |  Branch (356:11): [True: 0, False: 3.01k]
  ------------------
  357|  3.01k|    } else if (IsCharacterDigitForRadix(**current, radix, 'a')) {
  ------------------
  |  Branch (357:16): [True: 0, False: 0]
  ------------------
  358|      0|      digit = static_cast<char>(**current) - 'a' + 10;
  359|      0|      if (post_decimal) unclamped_exponent -= radix_log_2;
  ------------------
  |  Branch (359:11): [True: 0, False: 0]
  ------------------
  360|      0|    } else if (IsCharacterDigitForRadix(**current, radix, 'A')) {
  ------------------
  |  Branch (360:16): [True: 0, False: 0]
  ------------------
  361|      0|      digit = static_cast<char>(**current) - 'A' + 10;
  362|      0|      if (post_decimal) unclamped_exponent -= radix_log_2;
  ------------------
  |  Branch (362:11): [True: 0, False: 0]
  ------------------
  363|      0|    } else if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (363:16): [True: 0, False: 0]
  |  Branch (363:38): [True: 0, False: 0]
  ------------------
  364|      0|      post_decimal = true;
  365|      0|      Advance(current, separator, radix, end);
  366|      0|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (366:7): [True: 0, False: 0]
  ------------------
  367|      0|      continue;
  368|      0|    } else if (parse_as_hex_float && (**current == 'p' || **current == 'P')) {
  ------------------
  |  Branch (368:16): [True: 0, False: 0]
  |  Branch (368:39): [True: 0, False: 0]
  |  Branch (368:59): [True: 0, False: 0]
  ------------------
  369|      0|      break;
  370|      0|    } else {
  371|       |      // Trailing whitespace is junk unless ALLOW_TRAILING_SPACES is set, as it
  372|       |      // is for decimal numbers.
  373|      0|      if (allow_trailing_junk ||
  ------------------
  |  Branch (373:11): [True: 0, False: 0]
  ------------------
  374|      0|          (allow_trailing_spaces && !AdvanceToNonspace(current, end))) {
  ------------------
  |  Branch (374:12): [True: 0, False: 0]
  |  Branch (374:37): [True: 0, False: 0]
  ------------------
  375|      0|        break;
  376|      0|      } else {
  377|      0|        return junk_string_value;
  378|      0|      }
  379|      0|    }
  380|       |
  381|  3.01k|    number = number * radix + digit;
  382|  3.01k|    int overflow = static_cast<int>(number >> kSignificandSize);
  383|  3.01k|    if (overflow != 0) {
  ------------------
  |  Branch (383:9): [True: 113, False: 2.90k]
  ------------------
  384|       |      // Overflow occurred. Need to determine which direction to round the
  385|       |      // result.
  386|    113|      int overflow_bits_count = 1;
  387|    143|      while (overflow > 1) {
  ------------------
  |  Branch (387:14): [True: 30, False: 113]
  ------------------
  388|     30|        overflow_bits_count++;
  389|     30|        overflow >>= 1;
  390|     30|      }
  391|       |
  392|    113|      int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
  393|    113|      int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
  394|    113|      if (parse_as_hex_float && read_as_double) {
  ------------------
  |  Branch (394:11): [True: 0, False: 113]
  |  Branch (394:33): [True: 0, False: 0]
  ------------------
  395|      0|        hex_significand_overflowed = true;
  396|      0|        hex_exact_significand = number;
  397|      0|        hex_dropped_bits = overflow_bits_count;
  398|      0|      }
  399|    113|      number >>= overflow_bits_count;
  400|    113|      unclamped_exponent += overflow_bits_count;
  401|       |
  402|    113|      bool zero_tail = true;
  403|  5.46k|      for (;;) {
  404|  5.46k|        if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (404:13): [True: 113, False: 5.35k]
  ------------------
  405|  5.35k|        if (parse_as_hex_float && **current == '.') {
  ------------------
  |  Branch (405:13): [True: 0, False: 5.35k]
  |  Branch (405:35): [True: 0, False: 0]
  ------------------
  406|       |          // Just run over the '.'. We are just trying to see whether there is
  407|       |          // a non-zero digit somewhere.
  408|      0|          Advance(current, separator, radix, end);
  409|      0|          DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (409:11): [True: 0, False: 0]
  ------------------
  410|      0|          post_decimal = true;
  411|      0|        }
  412|  5.35k|        if (!isDigit(**current, radix)) break;
  ------------------
  |  Branch (412:13): [True: 0, False: 5.35k]
  ------------------
  413|  5.35k|        zero_tail = zero_tail && **current == '0';
  ------------------
  |  Branch (413:21): [True: 908, False: 4.44k]
  |  Branch (413:34): [True: 860, False: 48]
  ------------------
  414|  5.35k|        if (!post_decimal) unclamped_exponent += radix_log_2;
  ------------------
  |  Branch (414:13): [True: 5.35k, False: 0]
  ------------------
  415|  5.35k|      }
  416|       |
  417|    113|      if (!parse_as_hex_float && !allow_trailing_junk) {
  ------------------
  |  Branch (417:11): [True: 113, False: 0]
  |  Branch (417:34): [True: 0, False: 113]
  ------------------
  418|      0|        if (allow_trailing_spaces ? AdvanceToNonspace(current, end)
  ------------------
  |  Branch (418:13): [True: 0, False: 0]
  |  Branch (418:13): [True: 0, False: 0]
  ------------------
  419|      0|                                  : *current != end) {
  420|      0|          return junk_string_value;
  421|      0|        }
  422|      0|      }
  423|       |
  424|    113|      if (round_hex_float_to_single) {
  ------------------
  |  Branch (424:11): [True: 0, False: 113]
  ------------------
  425|       |        // Round the significand to odd: set the lowest kept bit whenever any
  426|       |        // bit was dropped. The caller rounds this double to float; rounding to
  427|       |        // nearest here would double-round, but round-to-odd leaves that final
  428|       |        // single rounding correct for normal and subnormal results alike.
  429|      0|        if (dropped_bits != 0 || !zero_tail) {
  ------------------
  |  Branch (429:13): [True: 0, False: 0]
  |  Branch (429:34): [True: 0, False: 0]
  ------------------
  430|      0|          number |= 1;
  431|      0|        }
  432|    113|      } else {
  433|    113|        if (hex_significand_overflowed) {
  ------------------
  |  Branch (433:13): [True: 0, False: 113]
  ------------------
  434|      0|          hex_significand_sticky = !zero_tail;
  435|      0|        }
  436|    113|        int middle_value = (1 << (overflow_bits_count - 1));
  437|    113|        if (dropped_bits > middle_value) {
  ------------------
  |  Branch (437:13): [True: 3, False: 110]
  ------------------
  438|      3|          number++;  // Rounding up.
  439|    110|        } else if (dropped_bits == middle_value) {
  ------------------
  |  Branch (439:20): [True: 54, False: 56]
  ------------------
  440|       |          // Rounding to even to consistency with decimals: half-way case rounds
  441|       |          // up if significant part is odd and down otherwise.
  442|     54|          if ((number & 1) != 0 || !zero_tail) {
  ------------------
  |  Branch (442:15): [True: 31, False: 23]
  |  Branch (442:36): [True: 8, False: 15]
  ------------------
  443|     39|            number++;  // Rounding up.
  444|     39|          }
  445|     54|        }
  446|       |
  447|       |        // Rounding up may cause overflow.
  448|    113|        if ((number & ((int64_t)1 << kSignificandSize)) != 0) {
  ------------------
  |  Branch (448:13): [True: 12, False: 101]
  ------------------
  449|     12|          unclamped_exponent++;
  450|     12|          number >>= 1;
  451|       |          // The exact significand keeps its scale, so it now sits one more bit
  452|       |          // below exponent.
  453|     12|          hex_dropped_bits++;
  454|     12|        }
  455|    113|      }
  456|    113|      break;
  457|    113|    }
  458|  2.90k|    if (Advance(current, separator, radix, end)) break;
  ------------------
  |  Branch (458:9): [True: 111, False: 2.79k]
  ------------------
  459|  2.90k|  }
  460|       |
  461|    224|  DOUBLE_CONVERSION_ASSERT(number < ((int64_t)1 << kSignificandSize));
  ------------------
  |  |   47|    224|    assert(condition)
  ------------------
  |  Branch (461:3): [True: 224, False: 0]
  ------------------
  462|    224|  DOUBLE_CONVERSION_ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
  ------------------
  |  |   47|    224|    assert(condition)
  ------------------
  |  Branch (462:3): [True: 224, False: 0]
  ------------------
  463|       |
  464|    224|  *result_is_junk = false;
  465|       |
  466|    224|  if (parse_as_hex_float) {
  ------------------
  |  Branch (466:7): [True: 0, False: 224]
  ------------------
  467|      0|    DOUBLE_CONVERSION_ASSERT(**current == 'p' || **current == 'P');
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (467:5): [True: 0, False: 0]
  |  Branch (467:5): [True: 0, False: 0]
  |  Branch (467:5): [True: 0, False: 0]
  ------------------
  468|       |    // The separator is only allowed between significand digits, not in the
  469|       |    // exponent, so advance through the exponent with no separator. This must
  470|       |    // match IsHexFloatString, which validated the string the same way.
  471|      0|    const uc16 kNoSeparator = StringToDoubleConverter::kNoSeparator;
  472|      0|    Advance(current, kNoSeparator, radix, end);
  473|      0|    DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (473:5): [True: 0, False: 0]
  ------------------
  474|      0|    bool is_negative = false;
  475|      0|    if (**current == '+') {
  ------------------
  |  Branch (475:9): [True: 0, False: 0]
  ------------------
  476|      0|      Advance(current, kNoSeparator, radix, end);
  477|      0|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (477:7): [True: 0, False: 0]
  ------------------
  478|      0|    } else if (**current == '-') {
  ------------------
  |  Branch (478:16): [True: 0, False: 0]
  ------------------
  479|      0|      is_negative = true;
  480|      0|      Advance(current, kNoSeparator, radix, end);
  481|      0|      DOUBLE_CONVERSION_ASSERT(*current != end);
  ------------------
  |  |   47|      0|    assert(condition)
  ------------------
  |  Branch (481:7): [True: 0, False: 0]
  ------------------
  482|      0|    }
  483|       |    // The written exponent is bounded only by the input length, so it still
  484|       |    // has to saturate, but stopping short of a written digit would change the
  485|       |    // result: the significand's exponent can cancel a written exponent of any
  486|       |    // size. Saturate past twice the largest magnitude that exponent can reach
  487|       |    // (radix_log_2 per character, over a length that is an int), so that a
  488|       |    // saturated written exponent always outweighs the significand and the sum
  489|       |    // keeps the sign of the exponent that was written.
  490|      0|    const int64_t max_written_exponent =
  491|      0|        2 * static_cast<int64_t>(radix_log_2) * INT_MAX;
  492|      0|    int64_t written_exponent = 0;
  493|      0|    while (IsDecimalDigitForRadix(**current, 10)) {
  ------------------
  |  Branch (493:12): [True: 0, False: 0]
  ------------------
  494|      0|      written_exponent = 10 * written_exponent + (**current - '0');
  495|      0|      if (written_exponent > max_written_exponent) {
  ------------------
  |  Branch (495:11): [True: 0, False: 0]
  ------------------
  496|      0|        written_exponent = max_written_exponent;
  497|      0|      }
  498|      0|      if (Advance(current, kNoSeparator, radix, end)) break;
  ------------------
  |  Branch (498:11): [True: 0, False: 0]
  ------------------
  499|      0|    }
  500|      0|    if (is_negative) written_exponent = -written_exponent;
  ------------------
  |  Branch (500:9): [True: 0, False: 0]
  ------------------
  501|      0|    unclamped_exponent += written_exponent;
  502|      0|  }
  503|       |
  504|       |  // Both parts were accumulated without loss, so clamping their sum now cannot
  505|       |  // cancel either of them. Below, an exponent this far out of range only has
  506|       |  // to keep its sign.
  507|    224|  int exponent;
  508|    224|  if (unclamped_exponent > max_exponent) {
  ------------------
  |  Branch (508:7): [True: 0, False: 224]
  ------------------
  509|      0|    exponent = max_exponent;
  510|    224|  } else if (unclamped_exponent < -max_exponent) {
  ------------------
  |  Branch (510:14): [True: 0, False: 224]
  ------------------
  511|      0|    exponent = -max_exponent;
  512|    224|  } else {
  513|    224|    exponent = static_cast<int>(unclamped_exponent);
  514|    224|  }
  515|       |
  516|    224|  if (exponent == 0 || number == 0) {
  ------------------
  |  Branch (516:7): [True: 111, False: 113]
  |  Branch (516:24): [True: 0, False: 113]
  ------------------
  517|    111|    if (sign) {
  ------------------
  |  Branch (517:9): [True: 53, False: 58]
  ------------------
  518|     53|      if (number == 0) return -0.0;
  ------------------
  |  Branch (518:11): [True: 0, False: 53]
  ------------------
  519|     53|      number = -number;
  520|     53|    }
  521|    111|    return static_cast<double>(number);
  522|    111|  }
  523|       |
  524|    113|  DOUBLE_CONVERSION_ASSERT(number != 0);
  ------------------
  |  |   47|    113|    assert(condition)
  ------------------
  |  Branch (524:3): [True: 113, False: 0]
  ------------------
  525|    113|  if (exponent > 100 * Double::kMaxExponent) {
  ------------------
  |  Branch (525:7): [True: 0, False: 113]
  ------------------
  526|      0|    return sign ? -Double::Infinity() : Double::Infinity();
  ------------------
  |  Branch (526:12): [True: 0, False: 0]
  ------------------
  527|      0|  }
  528|    113|  if (exponent < -100 * Double::kMaxExponent) {
  ------------------
  |  Branch (528:7): [True: 0, False: 113]
  ------------------
  529|      0|    return SignedZero(sign);
  530|      0|  }
  531|       |  // number is an exact integer below 2^kSignificandSize, so number * 2^exponent
  532|       |  // can be formed directly. Double(DiyFp(number, exponent)) would instead assume
  533|       |  // a normalized significand: a hex-float like "0x1p1000" or "0x2p-1075" reaches
  534|       |  // here with a small number and a large exponent, which DiyFpToUint64 then reads
  535|       |  // as an overflow (infinity) or underflow (zero) rather than the finite result.
  536|    113|  double result = ldexp(static_cast<double>(number), exponent);
  537|    113|  if (hex_significand_overflowed) {
  ------------------
  |  Branch (537:7): [True: 0, False: 113]
  ------------------
  538|       |    // Whether the result is subnormal is decided from the exact significand
  539|       |    // and its scale, not from result: result has already been rounded twice,
  540|       |    // and the second rounding can land it on zero or on the smallest normal.
  541|      0|    const int kDenormalExponent = -1074;
  542|      0|    int scale = exponent - hex_dropped_bits;  // binary scale of the exact LSB
  543|      0|    int drop = kDenormalExponent - scale;     // low bits to discard for the grid
  544|       |    // drop <= 0 is always a normal result. For drop >= 63 the exact value is
  545|       |    // below half the smallest subnormal, where the zero from ldexp is correct.
  546|      0|    if (drop > 0 && drop < 63) {
  ------------------
  |  Branch (546:9): [True: 0, False: 0]
  |  Branch (546:21): [True: 0, False: 0]
  ------------------
  547|      0|      int64_t high = hex_exact_significand >> drop;
  548|       |      // The smallest normal is 2^52 on the grid, and the exact value is below
  549|       |      // it exactly when high is.
  550|      0|      if (high < static_cast<int64_t>(Double::kHiddenBit)) {
  ------------------
  |  Branch (550:11): [True: 0, False: 0]
  ------------------
  551|       |        // Subnormal. Round the exact significand once, straight onto the
  552|       |        // 2^-1074 subnormal grid, instead of the round-to-nearest-then-ldexp
  553|       |        // double rounding.
  554|      0|        int64_t low = hex_exact_significand & (((int64_t)1 << drop) - 1);
  555|      0|        int64_t half = (int64_t)1 << (drop - 1);
  556|      0|        bool round_up = low > half ||
  ------------------
  |  Branch (556:25): [True: 0, False: 0]
  ------------------
  557|      0|            (low == half && (hex_significand_sticky || (high & 1) != 0));
  ------------------
  |  Branch (557:14): [True: 0, False: 0]
  |  Branch (557:30): [True: 0, False: 0]
  |  Branch (557:56): [True: 0, False: 0]
  ------------------
  558|      0|        if (round_up) high++;
  ------------------
  |  Branch (558:13): [True: 0, False: 0]
  ------------------
  559|      0|        result = ldexp(static_cast<double>(high), kDenormalExponent);
  560|      0|      }
  561|      0|    }
  562|      0|  }
  563|    113|  return sign ? -result : result;
  ------------------
  |  Branch (563:10): [True: 1, False: 112]
  ------------------
  564|    113|}
string-to-double.cc:_ZN17double_conversionL7AdvanceIPcEEbPT_tiRS2_:
  221|  8.37k|static bool Advance (Iterator* it, uc16 separator, int base, Iterator& end) {
  222|  8.37k|  if (separator == StringToDoubleConverter::kNoSeparator) {
  ------------------
  |  Branch (222:7): [True: 8.37k, False: 0]
  ------------------
  223|  8.37k|    ++(*it);
  224|  8.37k|    return *it == end;
  225|  8.37k|  }
  226|      0|  if (!isDigit(**it, base)) {
  ------------------
  |  Branch (226:7): [True: 0, False: 0]
  ------------------
  227|      0|    ++(*it);
  228|      0|    return *it == end;
  229|      0|  }
  230|      0|  ++(*it);
  231|      0|  if (*it == end) return true;
  ------------------
  |  Branch (231:7): [True: 0, False: 0]
  ------------------
  232|      0|  if (*it + 1 == end) return false;
  ------------------
  |  Branch (232:7): [True: 0, False: 0]
  ------------------
  233|      0|  if (**it == separator && isDigit(*(*it + 1), base)) {
  ------------------
  |  Branch (233:7): [True: 0, False: 0]
  |  Branch (233:28): [True: 0, False: 0]
  ------------------
  234|      0|    ++(*it);
  235|      0|  }
  236|      0|  return *it == end;
  237|      0|}

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

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

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

_ZN17double_conversion7BitCastIdmEET_RKT0_:
  395|  2.98k|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.98k|#if __cplusplus >= 201103L
  399|  2.98k|  static_assert(sizeof(Dest) == sizeof(Source),
  400|  2.98k|                "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.98k|  Dest dest;
  407|  2.98k|  memmove(&dest, &source, sizeof(dest));
  408|  2.98k|  return dest;
  409|  2.98k|}
_ZN17double_conversion6VectorIKcEC2EPS1_i:
  252|  4.07k|  Vector(T* data, int len) : start_(data), length_(len) {
  253|       |    DOUBLE_CONVERSION_ASSERT(len == 0 || (len > 0 && data != DOUBLE_CONVERSION_NULLPTR));
  ------------------
  |  |   47|  4.07k|    assert(condition)
  ------------------
  |  Branch (253:5): [True: 3.88k, False: 0]
  |  Branch (253:5): [True: 3.88k, False: 0]
  |  Branch (253:5): [True: 192, False: 3.88k]
  |  Branch (253:5): [True: 4.07k, False: 0]
  ------------------
  254|  4.07k|  }
_ZNK17double_conversion6VectorIKcEixEi:
  275|   237k|  T& operator[](int index) const {
  276|   237k|    DOUBLE_CONVERSION_ASSERT(0 <= index && index < length_);
  ------------------
  |  |   47|   237k|    assert(condition)
  ------------------
  |  Branch (276:5): [True: 237k, False: 0]
  |  Branch (276:5): [True: 237k, False: 0]
  |  Branch (276:5): [True: 237k, False: 0]
  ------------------
  277|   237k|    return start_[index];
  278|   237k|  }
_ZN17double_conversion6VectorIKcE9SubVectorEii:
  258|  1.94k|  Vector<T> SubVector(int from, int to) {
  259|  1.94k|    DOUBLE_CONVERSION_ASSERT(to <= length_);
  ------------------
  |  |   47|  1.94k|    assert(condition)
  ------------------
  |  Branch (259:5): [True: 1.94k, False: 0]
  ------------------
  260|  1.94k|    DOUBLE_CONVERSION_ASSERT(from < to);
  ------------------
  |  |   47|  1.94k|    assert(condition)
  ------------------
  |  Branch (260:5): [True: 1.94k, False: 0]
  ------------------
  261|  1.94k|    DOUBLE_CONVERSION_ASSERT(0 <= from);
  ------------------
  |  |   47|  1.94k|    assert(condition)
  ------------------
  |  Branch (261:5): [True: 1.94k, False: 0]
  ------------------
  262|  1.94k|    return Vector<T>(start() + from, to - from);
  263|  1.94k|  }
_ZNK17double_conversion6VectorIKcE5startEv:
  272|  2.03k|  T* start() const { return start_; }
_ZNK17double_conversion6VectorIKcE6lengthEv:
  266|   178k|  int length() const { return length_; }
_ZN17double_conversion7BitCastImdEET_RKT0_:
  395|  1.39k|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.39k|#if __cplusplus >= 201103L
  399|  1.39k|  static_assert(sizeof(Dest) == sizeof(Source),
  400|  1.39k|                "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.39k|  Dest dest;
  407|  1.39k|  memmove(&dest, &source, sizeof(dest));
  408|  1.39k|  return dest;
  409|  1.39k|}

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