_ZN4absl12lts_2024011613base_internal16SchedulingHelperC2ENS1_14SchedulingModeE:
  116|     26|  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
  117|     26|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (117:9): [True: 0, False: 26]
  ------------------
  118|      0|      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
  119|      0|    }
  120|     26|  }
_ZN4absl12lts_2024011613base_internal16SchedulingHelperD2Ev:
  122|     26|  ~SchedulingHelper() {
  123|     26|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (123:9): [True: 0, False: 26]
  ------------------
  124|      0|      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
  125|      0|    }
  126|     26|  }
_ZN4absl12lts_2024011613base_internal11ControlWordEPNS0_9once_flagE:
  193|     46|    absl::Nonnull<once_flag*> flag) {
  194|     46|  return &flag->control_;
  195|     46|}
_ZN4absl12lts_202401169call_onceIMNS0_14flags_internal8FlagImplEFvvEJPS3_EEEvRNS0_9once_flagEOT_DpOT0_:
  212|     44|void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  213|     44|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  214|     44|  uint32_t s = once->load(std::memory_order_acquire);
  215|     44|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  178|     44|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 24, False: 20]
  |  |  |  Branch (178:49): [Folded, False: 44]
  |  |  |  Branch (178:58): [True: 24, False: 20]
  |  |  ------------------
  ------------------
  216|     24|    base_internal::CallOnceImpl(
  217|     24|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  218|     24|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  219|     24|  }
  220|     44|}
_ZN4absl12lts_2024011613base_internal12CallOnceImplIMNS0_14flags_internal8FlagImplEFvvEJPS4_EEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  153|     24|    Args&&... args) {
  154|       |#ifndef NDEBUG
  155|       |  {
  156|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  157|       |    if (old_control != kOnceInit &&
  158|       |        old_control != kOnceRunning &&
  159|       |        old_control != kOnceWaiter &&
  160|       |        old_control != kOnceDone) {
  161|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  162|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  163|       |    }
  164|       |  }
  165|       |#endif  // NDEBUG
  166|     24|  static const base_internal::SpinLockWaitTransition trans[] = {
  167|     24|      {kOnceInit, kOnceRunning, true},
  168|     24|      {kOnceRunning, kOnceWaiter, false},
  169|     24|      {kOnceDone, kOnceDone, true}};
  170|       |
  171|       |  // Must do this before potentially modifying control word's state.
  172|     24|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  173|       |  // Short circuit the simplest case to avoid procedure call overhead.
  174|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  175|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  176|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  177|     24|  uint32_t old_control = kOnceInit;
  178|     24|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (178:7): [True: 24, False: 0]
  ------------------
  179|     24|                                       std::memory_order_relaxed) ||
  180|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   45|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (180:7): [True: 0, False: 0]
  ------------------
  181|     24|                                  scheduling_mode) == kOnceInit) {
  182|     24|    base_internal::invoke(std::forward<Callable>(fn),
  183|     24|                          std::forward<Args>(args)...);
  184|     24|    old_control =
  185|     24|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  186|     24|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (186:9): [True: 0, False: 24]
  ------------------
  187|      0|      base_internal::SpinLockWake(control, true);
  188|      0|    }
  189|     24|  }  // else *control is already kOnceDone
  190|     24|}
_ZN4absl12lts_202401169call_onceIRFvvEJEEEvRNS0_9once_flagEOT_DpOT0_:
  212|      2|void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  213|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  214|      2|  uint32_t s = once->load(std::memory_order_acquire);
  215|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 2, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  Branch (178:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  216|      2|    base_internal::CallOnceImpl(
  217|      2|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  218|      2|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  219|      2|  }
  220|      2|}
_ZN4absl12lts_2024011613base_internal12CallOnceImplIRFvvEJEEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  153|      2|    Args&&... args) {
  154|       |#ifndef NDEBUG
  155|       |  {
  156|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  157|       |    if (old_control != kOnceInit &&
  158|       |        old_control != kOnceRunning &&
  159|       |        old_control != kOnceWaiter &&
  160|       |        old_control != kOnceDone) {
  161|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  162|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  163|       |    }
  164|       |  }
  165|       |#endif  // NDEBUG
  166|      2|  static const base_internal::SpinLockWaitTransition trans[] = {
  167|      2|      {kOnceInit, kOnceRunning, true},
  168|      2|      {kOnceRunning, kOnceWaiter, false},
  169|      2|      {kOnceDone, kOnceDone, true}};
  170|       |
  171|       |  // Must do this before potentially modifying control word's state.
  172|      2|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  173|       |  // Short circuit the simplest case to avoid procedure call overhead.
  174|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  175|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  176|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  177|      2|  uint32_t old_control = kOnceInit;
  178|      2|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (178:7): [True: 2, False: 0]
  ------------------
  179|      2|                                       std::memory_order_relaxed) ||
  180|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   45|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (180:7): [True: 0, False: 0]
  ------------------
  181|      2|                                  scheduling_mode) == kOnceInit) {
  182|      2|    base_internal::invoke(std::forward<Callable>(fn),
  183|      2|                          std::forward<Args>(args)...);
  184|      2|    old_control =
  185|      2|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  186|      2|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (186:9): [True: 0, False: 2]
  ------------------
  187|      0|      base_internal::SpinLockWake(control, true);
  188|      0|    }
  189|      2|  }  // else *control is already kOnceDone
  190|      2|}

_ZN4absl12lts_202401168bit_castImlTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  2.36k|inline constexpr Dest bit_cast(const Source& source) {
  164|  2.36k|  return __builtin_bit_cast(Dest, source);
  165|  2.36k|}
_ZN4absl12lts_202401168bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  1.18k|inline constexpr Dest bit_cast(const Source& source) {
  164|  1.18k|  return __builtin_bit_cast(Dest, source);
  165|  1.18k|}
_ZN4absl12lts_202401168bit_castINS0_14flags_internal19FlagValueAndInitBitIbEElTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS8_EE5valuesr3std21is_trivially_copyableIS7_EE5valueEiE4typeELi0EEES7_RKS8_:
  163|      8|inline constexpr Dest bit_cast(const Source& source) {
  164|      8|  return __builtin_bit_cast(Dest, source);
  165|      8|}
_ZN4absl12lts_202401168bit_castIlNSt3__15arrayIcLm8EEETnNS2_9enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS7_EE5valuesr3std21is_trivially_copyableIS6_EE5valueEiE4typeELi0EEES6_RKS7_:
  163|     10|inline constexpr Dest bit_cast(const Source& source) {
  164|     10|  return __builtin_bit_cast(Dest, source);
  165|     10|}
_ZN4absl12lts_202401168bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  163|  16.3k|inline constexpr Dest bit_cast(const Source& source) {
  164|  16.3k|  return __builtin_bit_cast(Dest, source);
  165|  16.3k|}

_ZN4absl12lts_202401169gbswap_32Ej:
   48|     20|inline uint32_t gbswap_32(uint32_t host_int) {
   49|     20|#if ABSL_HAVE_BUILTIN(__builtin_bswap32) || defined(__GNUC__)
   50|     20|  return __builtin_bswap32(host_int);
   51|       |#elif defined(_MSC_VER)
   52|       |  return _byteswap_ulong(host_int);
   53|       |#else
   54|       |  return (((host_int & uint32_t{0xFF}) << 24) |
   55|       |          ((host_int & uint32_t{0xFF00}) << 8) |
   56|       |          ((host_int & uint32_t{0xFF0000}) >> 8) |
   57|       |          ((host_int & uint32_t{0xFF000000}) >> 24));
   58|       |#endif
   59|     20|}
_ZN4absl12lts_202401169gbswap_16Et:
   61|      2|inline uint16_t gbswap_16(uint16_t host_int) {
   62|      2|#if ABSL_HAVE_BUILTIN(__builtin_bswap16) || defined(__GNUC__)
   63|      2|  return __builtin_bswap16(host_int);
   64|       |#elif defined(_MSC_VER)
   65|       |  return _byteswap_ushort(host_int);
   66|       |#else
   67|       |  return (((host_int & uint16_t{0xFF}) << 8) |
   68|       |          ((host_int & uint16_t{0xFF00}) >> 8));
   69|       |#endif
   70|      2|}
_ZN4absl12lts_2024011613little_endian8ToHost64Em:
  114|     16|inline uint64_t ToHost64(uint64_t x) { return x; }
_ZN4absl12lts_2024011613little_endian6ToHostEm:
  140|     16|inline uint64_t ToHost(uint64_t x) { return ToHost64(x); }
_ZN4absl12lts_2024011610big_endian8ToHost16Et:
  198|      2|inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
_ZN4absl12lts_2024011610big_endian8ToHost32Ej:
  201|     20|inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
_ZN4absl12lts_2024011610big_endian6Load16EPKv:
  254|      2|inline uint16_t Load16(absl::Nonnull<const void *> p) {
  255|      2|  return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
  ------------------
  |  |   74|      2|  (absl::base_internal::UnalignedLoad16(_p))
  ------------------
  256|      2|}
_ZN4absl12lts_2024011610big_endian6Load32EPKv:
  262|     20|inline uint32_t Load32(absl::Nonnull<const void *> p) {
  263|     20|  return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
  ------------------
  |  |   76|     20|  (absl::base_internal::UnalignedLoad32(_p))
  ------------------
  264|     20|}

_ZN4absl12lts_2024011613base_internal10FastTypeIdIbEEPKvv:
   42|      2|constexpr inline FastTypeIdType FastTypeId() {
   43|      2|  return &FastTypeTag<Type>::dummy_var;
   44|      2|}
_ZN4absl12lts_2024011613base_internal10FastTypeIdINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPKvv:
   42|      2|constexpr inline FastTypeIdType FastTypeId() {
   43|      2|  return &FastTypeTag<Type>::dummy_var;
   44|      2|}

_ZN4absl12lts_2024011613base_internal8SpinLockC2Ev:
   58|     16|  SpinLock() : lockword_(kSpinLockCooperative) {
   59|     16|    ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
   60|     16|  }
_ZN4absl12lts_2024011613base_internal8SpinLock4LockEv:
   80|     18|  inline void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
   81|     18|    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   82|     18|    if (!TryLockImpl()) {
  ------------------
  |  Branch (82:9): [True: 0, False: 18]
  ------------------
   83|      0|      SlowLock();
   84|      0|    }
   85|     18|    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
   86|     18|  }
_ZN4absl12lts_2024011613base_internal8SpinLock6UnlockEv:
  102|     18|  inline void Unlock() ABSL_UNLOCK_FUNCTION() {
  103|     18|    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
  104|     18|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  105|     18|    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
  106|     18|                                    std::memory_order_release);
  107|       |
  108|     18|    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
  ------------------
  |  Branch (108:9): [True: 0, False: 18]
  ------------------
  109|      0|      base_internal::SchedulingGuard::EnableRescheduling(true);
  110|      0|    }
  111|     18|    if ((lock_value & kWaitTimeMask) != 0) {
  ------------------
  |  Branch (111:9): [True: 0, False: 18]
  ------------------
  112|       |      // Collect contentionz profile info, and speed the wakeup of any waiter.
  113|       |      // The wait_cycles value indicates how long this thread spent waiting
  114|       |      // for the lock.
  115|      0|      SlowUnlock(lock_value);
  116|      0|    }
  117|     18|    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
  118|     18|  }
_ZN4absl12lts_2024011613base_internal8SpinLock11TryLockImplEv:
  192|     18|  inline bool TryLockImpl() {
  193|     18|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  194|     18|    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
  195|     18|  }
_ZN4absl12lts_2024011613base_internal14SpinLockHolderC2EPNS1_8SpinLockE:
  208|     18|      : lock_(l) {
  209|     18|    l->Lock();
  210|     18|  }
_ZN4absl12lts_2024011613base_internal14SpinLockHolderD2Ev:
  211|     18|  inline ~SpinLockHolder() ABSL_UNLOCK_FUNCTION() { lock_->Unlock(); }
_ZN4absl12lts_2024011613base_internal8SpinLock15TryLockInternalEjj:
  237|     18|                                          uint32_t wait_cycles) {
  238|     18|  if ((lock_value & kSpinLockHeld) != 0) {
  ------------------
  |  Branch (238:7): [True: 0, False: 18]
  ------------------
  239|      0|    return lock_value;
  240|      0|  }
  241|       |
  242|     18|  uint32_t sched_disabled_bit = 0;
  243|     18|  if ((lock_value & kSpinLockCooperative) == 0) {
  ------------------
  |  Branch (243:7): [True: 0, False: 18]
  ------------------
  244|       |    // For non-cooperative locks we must make sure we mark ourselves as
  245|       |    // non-reschedulable before we attempt to CompareAndSwap.
  246|      0|    if (base_internal::SchedulingGuard::DisableRescheduling()) {
  ------------------
  |  Branch (246:9): [True: 0, False: 0]
  ------------------
  247|      0|      sched_disabled_bit = kSpinLockDisabledScheduling;
  248|      0|    }
  249|      0|  }
  250|       |
  251|     18|  if (!lockword_.compare_exchange_strong(
  ------------------
  |  Branch (251:7): [True: 0, False: 18]
  ------------------
  252|     18|          lock_value,
  253|     18|          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
  254|     18|          std::memory_order_acquire, std::memory_order_relaxed)) {
  255|      0|    base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
  256|      0|  }
  257|       |
  258|     18|  return lock_value;
  259|     18|}

_ZN4absl12lts_2024011613base_internal15UnalignedLoad64EPKv:
   51|     36|inline uint64_t UnalignedLoad64(absl::Nonnull<const void *> p) {
   52|     36|  uint64_t t;
   53|     36|  memcpy(&t, p, sizeof t);
   54|     36|  return t;
   55|     36|}
_ZN4absl12lts_2024011613base_internal15UnalignedLoad32EPKv:
   45|    104|inline uint32_t UnalignedLoad32(absl::Nonnull<const void *> p) {
   46|    104|  uint32_t t;
   47|    104|  memcpy(&t, p, sizeof t);
   48|    104|  return t;
   49|    104|}
_ZN4absl12lts_2024011613base_internal15UnalignedLoad16EPKv:
   39|      2|inline uint16_t UnalignedLoad16(absl::Nonnull<const void *> p) {
   40|      2|  uint16_t t;
   41|      2|  memcpy(&t, p, sizeof t);
   42|      2|  return t;
   43|      2|}

_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS4_EEE5valueEiE4typeELi0EEEDpOS8_:
  127|      2|      : impl_(std::forward<Ts>(args)...) {}
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImplC2IJEEEDpOT_:
  165|      2|    explicit PlacementImpl(Args&&... args) {
  166|      2|      new (&space_) T(std::forward<Args>(args)...);
  167|      2|    }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEEdeEv:
  142|     30|  T& operator*() { return *get(); }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE3getEv:
  144|     30|  T* get() { return impl_.get(); }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl3getEv:
  171|     30|    T* get() { return Launder(reinterpret_cast<T*>(&space_)); }
_ZN4absl12lts_2024011612NoDestructorINS0_14flags_internal12FlagRegistryEE13PlacementImpl7LaunderIS3_EEPT_S8_:
  175|     30|    static P* Launder(P* p) {
  176|     30|#if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606L
  177|     30|      return std::launder(p);
  178|       |#elif ABSL_HAVE_BUILTIN(__builtin_launder)
  179|       |      return __builtin_launder(p);
  180|       |#else
  181|       |      // When `std::launder` or equivalent are not available, we rely on
  182|       |      // undefined behavior, which works as intended on Abseil's officially
  183|       |      // supported platforms as of Q3 2023.
  184|       |#if defined(__GNUC__) && !defined(__clang__)
  185|       |#pragma GCC diagnostic push
  186|       |#pragma GCC diagnostic ignored "-Wstrict-aliasing"
  187|       |#endif
  188|       |      return p;
  189|       |#if defined(__GNUC__) && !defined(__clang__)
  190|       |#pragma GCC diagnostic pop
  191|       |#endif
  192|       |#endif
  193|     30|    }

_ZN4absl12lts_2024011620PrefetchToLocalCacheEPKv:
  146|      6|    const void* addr) {
  147|      6|  __builtin_prefetch(addr, 0, 3);
  148|      6|}

_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7elementEPNS1_13map_slot_typeIS7_S9_EE:
  597|     27|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7destroyINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EE:
  577|     26|  static void destroy(Allocator* alloc, slot_type* slot) {
  578|     26|    slot_policy::destroy(alloc, slot);
  579|     26|  }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE12EqualElementIS7_EEJRSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSO_DpOSP_:
  590|      1|  apply(F&& f, Args&&... args) {
  591|      1|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  592|      1|                                                   std::forward<Args>(args)...);
  593|      1|  }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE5applyINS1_12raw_hash_setISA_NS1_10StringHashENS1_8StringEqENS3_9allocatorINS3_4pairIKS7_S9_EEEEE19EmplaceDecomposableEJSI_EEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSM_DpOSN_:
  590|     26|  apply(F&& f, Args&&... args) {
  591|     26|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  592|     26|                                                   std::forward<Args>(args)...);
  593|     26|  }
_ZN4absl12lts_2024011618container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_:
  572|     26|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  573|     26|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  574|     26|  }
_ZN4absl12lts_2024011613flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagENS0_18container_internal10StringHashENS9_8StringEqENS2_9allocatorINS2_4pairIKS6_S8_EEEEEC2Ev:
  159|      2|  flat_hash_map() {}

_ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_SA_EE:
   75|     27|      -> decltype(P::element(slot)) {
   76|     27|    return P::element(slot);
   77|     27|  }
_ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE7destroyINS4_9allocatorINS4_4pairIKS8_SA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EE:
   49|     26|  static void destroy(Alloc* alloc, slot_type* slot) {
   50|     26|    Policy::destroy(alloc, slot);
   51|     26|  }
_ZN4absl12lts_2024011618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE9constructINS4_9allocatorINS4_4pairIKS8_SA_EEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSM_IJOSA_EEEEEEvPT_PNS1_13map_slot_typeIS8_SA_EEDpOT0_:
   42|     26|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   43|     26|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   44|     26|  }

_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EEC2IS4_EENSt3__110in_place_tEOT_:
   90|      2|      : value(absl::forward<V>(v)) {}
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv:
   92|    276|  T& get() & { return value; }
_ZNKR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ELb0EE3getEv:
   91|    255|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  246|    255|  constexpr const ElemT<I>& get() const& {
  247|    255|    return StorageT<I>::get();
  248|    255|  }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|    276|  ElemT<I>& get() & {
  242|    276|    return StorageT<I>::get();
  243|    276|  }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|     60|  ElemT<I>& get() & {
  242|     60|    return StorageT<I>::get();
  243|     60|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKNS4_17basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEELm3ELb1EE3getEv:
  106|     60|  T& get() & { return *this; }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|      1|  ElemT<I>& get() & {
  242|      1|    return StorageT<I>::get();
  243|      1|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EE3getEv:
  106|      1|  T& get() & { return *this; }
_ZNR4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISI_XT_EE4typeEv:
  241|     26|  ElemT<I>& get() & {
  242|     26|    return StorageT<I>::get();
  243|     26|  }
_ZNR4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ELb1EE3getEv:
  106|     26|  T& get() & { return *this; }
_ZN4absl12lts_2024011618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS6_4pairIKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEC2IS3_JS4_S5_SH_ETnNS6_9enable_ifIXsr4absl11conjunctionINS0_8negationINS6_7is_sameIFvSI_EFvNS6_5decayIT_E4typeEEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISI_JSP_DpT0_EEEEE5valueEbE4typeELb1EEEOSP_DpOSX_:
  236|      2|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  237|      2|                                             absl::forward<First>(first),
  238|      2|                                             absl::forward<Vs>(base)...) {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorINS8_4pairIKNS8_17basic_string_viewIcNS8_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SJ_EEENS8_10in_place_tEDpOT_:
  126|      8|      : Storage<Ts, I>(absl::in_place, absl::forward<Vs>(args))... {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ELb1EEC2IS4_EENSt3__110in_place_tEOT_:
  103|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ELb1EEC2IS4_EENSt3__110in_place_tEOT_:
  103|      2|      : T(absl::forward<V>(v)) {}
_ZN4absl12lts_2024011618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS4_4pairIKNS4_17basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEELm3ELb1EEC2ISF_EENS4_10in_place_tEOT_:
  103|      2|      : T(absl::forward<V>(v)) {}

_ZN4absl12lts_2024011618container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   55|      8|void* Allocate(Alloc* alloc, size_t n) {
   56|      8|  static_assert(Alignment > 0, "");
   57|      8|  assert(n && "n must be positive");
   58|      8|  using M = AlignedType<Alignment>;
   59|      8|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   60|      8|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   61|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   62|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   63|       |  // with the "foo(bar)" syntax.
   64|      8|  A my_mem_alloc(*alloc);
   65|      8|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   66|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   67|      8|         "allocator does not respect alignment");
   68|      8|  return p;
   69|      8|}
_ZN4absl12lts_2024011618container_internal27SanitizerPoisonMemoryRegionEPKvm:
  220|     32|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
  221|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  222|       |  ASAN_POISON_MEMORY_REGION(m, s);
  223|       |#endif
  224|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  225|       |  __msan_poison(m, s);
  226|       |#endif
  227|     32|  (void)m;
  228|     32|  (void)s;
  229|     32|}
_ZN4absl12lts_2024011618container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  231|     38|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
  232|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  233|       |  ASAN_UNPOISON_MEMORY_REGION(m, s);
  234|       |#endif
  235|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  236|       |  __msan_unpoison(m, s);
  237|       |#endif
  238|     38|  (void)m;
  239|     38|  (void)s;
  240|     38|}
_ZN4absl12lts_2024011618container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm:
   74|      6|void Deallocate(Alloc* alloc, void* p, size_t n) {
   75|      6|  static_assert(Alignment > 0, "");
   76|      6|  assert(n && "n must be positive");
   77|      6|  using M = AlignedType<Alignment>;
   78|      6|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   79|      6|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   80|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   81|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   82|       |  // with the "foo(bar)" syntax.
   83|      6|  A my_mem_alloc(*alloc);
   84|      6|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
   85|      6|                 (n + sizeof(M) - 1) / sizeof(M));
   86|      6|}
_ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7destroyINS3_9allocatorINS3_4pairIKS7_S9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EE:
  417|     26|  static void destroy(Allocator* alloc, slot_type* slot) {
  418|     26|    if (kMutableKeys::value) {
  ------------------
  |  Branch (418:9): [True: 26, Folded]
  ------------------
  419|     26|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  420|     26|    } else {
  421|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  422|      0|    }
  423|     26|  }
_ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE12EqualElementIS9_EEJRSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSO_DpOSP_:
  206|      1|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  207|      1|  return memory_internal::DecomposePairImpl(
  208|      1|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  209|      1|}
_ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE12EqualElementISA_EERSI_NS6_5tupleIJRKSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSP_IJSU_EEEEEclsr3stdE7declvalIT1_EEEEOST_NSH_ISX_SY_EE:
  138|      1|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  139|      1|  const auto& key = std::get<0>(p.first);
  140|      1|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  141|      1|                            std::move(p.second));
  142|      1|}
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  187|      1|    const std::pair<F, S>& p) {
  188|      1|  return PairArgs(p.first, p.second);
  189|      1|}
_ZN4absl12lts_2024011618container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  181|      1|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  182|      1|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  183|      1|          std::forward_as_tuple(std::forward<S>(s))};
  184|      1|}
_ZN4absl12lts_2024011618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS5_9allocatorINS5_4pairIKS9_SB_EEEEE19EmplaceDecomposableEJSI_EEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSM_DpOSN_:
  206|     26|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  207|     26|  return memory_internal::DecomposePairImpl(
  208|     26|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  209|     26|}
_ZN4absl12lts_2024011618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS6_9allocatorINS6_4pairIKSA_SC_EEEEE19EmplaceDecomposableEOSI_NS6_5tupleIJOSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSO_IJSS_EEEEEclsr3stdE7declvalIT1_EEEEOSR_NSH_ISV_SW_EE:
  138|     26|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  139|     26|  const auto& key = std::get<0>(p.first);
  140|     26|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  141|     26|                            std::move(p.second));
  142|     26|}
_ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE7emplaceEPNS1_13map_slot_typeIS7_S9_EE:
  348|     26|  static void emplace(slot_type* slot) {
  349|       |    // The construction of union doesn't do anything at runtime but it allows us
  350|       |    // to access its members without violating aliasing rules.
  351|     26|    new (slot) slot_type;
  352|     26|  }
_ZN4absl12lts_2024011618container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEC2Ev:
  329|     26|  map_slot_type() {}
_ZN4absl12lts_2024011618container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEE9constructINS3_9allocatorINS3_4pairIKS7_S9_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOSE_EEENSK_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS7_S9_EEDpOT0_:
  383|     26|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  384|     26|    emplace(slot);
  385|     26|    if (kMutableKeys::value) {
  ------------------
  |  Branch (385:9): [True: 26, Folded]
  ------------------
  386|     26|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  387|     26|                                                   std::forward<Args>(args)...);
  388|     26|    } else {
  389|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  390|      0|                                                   std::forward<Args>(args)...);
  391|      0|    }
  392|     26|  }
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEEONSB_ISD_SG_EE:
  191|     26|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
  192|     26|  return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
  193|     26|}
_ZN4absl12lts_2024011618container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS3_4pairINS3_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_:
  181|     26|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  182|     26|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  183|     26|          std::forward_as_tuple(std::forward<S>(s))};
  184|     26|}

_ZNK4absl12lts_2024011618container_internal10StringHashclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   77|     26|  size_t operator()(absl::string_view v) const {
   78|     26|    return absl::Hash<absl::string_view>{}(v);
   79|     26|  }
_ZNK4absl12lts_2024011618container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_:
   87|      1|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   88|      1|    return lhs == rhs;
   89|      1|  }

_ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE12EqualElementIS8_EEJRSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSR_DpOSS_:
  133|      1|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|      1|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|      1|  }
_ZN4absl12lts_2024011618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEvE5applyINS1_12raw_hash_setISB_NS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19EmplaceDecomposableEJSK_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSP_DpOSQ_:
  133|     26|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  134|     26|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  135|     26|  }

_ZN4absl12lts_2024011618container_internal6SampleEm:
  210|      2|    size_t inline_element_size ABSL_ATTRIBUTE_UNUSED) {
  211|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  212|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  213|       |    return HashtablezInfoHandle(nullptr);
  214|       |  }
  215|       |  return HashtablezInfoHandle(
  216|       |      SampleSlow(global_next_sample, inline_element_size));
  217|       |#else
  218|      2|  return HashtablezInfoHandle(nullptr);
  219|      2|#endif  // !ABSL_PER_THREAD_TLS
  220|      2|}
_ZN4absl12lts_2024011618container_internal20HashtablezInfoHandleC2EDn:
  187|      2|  explicit HashtablezInfoHandle(std::nullptr_t) {}
_ZNK4absl12lts_2024011618container_internal20HashtablezInfoHandle9IsSampledEv:
  190|      8|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  191|      2|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2024011618container_internal20HashtablezInfoHandle12RecordInsertEmm:
  195|     26|  inline void RecordInsert(size_t /*hash*/, size_t /*distance_from_desired*/) {}

_ZN4absl12lts_2024011618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEEC2Ev:
   64|      2|  raw_hash_map() {}

_ZN4absl12lts_2024011618container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEb:
  256|      2|                       bool reuse) {
  257|      2|  c.set_size(0);
  258|      2|  if (reuse) {
  ------------------
  |  Branch (258:7): [True: 2, False: 0]
  ------------------
  259|      2|    ResetCtrl(c, policy.slot_size);
  260|      2|    ResetGrowthLeft(c);
  261|      2|    c.infoz().RecordStorageChanged(0, c.capacity());
  262|      2|  } else {
  263|       |    // We need to record infoz before calling dealloc, which will unregister
  264|       |    // infoz.
  265|      0|    c.infoz().RecordClearedReservation();
  266|      0|    c.infoz().RecordStorageChanged(0, 0);
  267|      0|    (*policy.dealloc)(c, policy);
  268|      0|    c.set_control(EmptyGroup());
  269|      0|    c.set_generation_ptr(EmptyGeneration());
  270|      0|    c.set_slots(nullptr);
  271|      0|    c.set_capacity(0);
  272|      0|  }
  273|      2|}
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper38GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEm:
  276|      6|    ctrl_t* new_ctrl, size_t new_capacity) const {
  277|      6|  assert(is_single_group(new_capacity));
  278|      6|  constexpr size_t kHalfWidth = Group::kWidth / 2;
  279|      6|  assert(old_capacity_ < kHalfWidth);
  280|       |
  281|      6|  const size_t half_old_capacity = old_capacity_ / 2;
  282|       |
  283|       |  // NOTE: operations are done with compile time known size = kHalfWidth.
  284|       |  // Compiler optimizes that into single ASM operation.
  285|       |
  286|       |  // Copy second half of bytes to the beginning.
  287|       |  // We potentially copy more bytes in order to have compile time known size.
  288|       |  // Mirrored bytes from the old_ctrl_ will also be copied.
  289|       |  // In case of old_capacity_ == 3, we will copy 1st element twice.
  290|       |  // Examples:
  291|       |  // old_ctrl = 0S0EEEEEEE...
  292|       |  // new_ctrl = S0EEEEEEEE...
  293|       |  //
  294|       |  // old_ctrl = 01S01EEEEE...
  295|       |  // new_ctrl = 1S01EEEEEE...
  296|       |  //
  297|       |  // old_ctrl = 0123456S0123456EE...
  298|       |  // new_ctrl = 456S0123?????????...
  299|      6|  std::memcpy(new_ctrl, old_ctrl_ + half_old_capacity + 1, kHalfWidth);
  300|       |  // Clean up copied kSentinel from old_ctrl.
  301|      6|  new_ctrl[half_old_capacity] = ctrl_t::kEmpty;
  302|       |
  303|       |  // Clean up damaged or uninitialized bytes.
  304|       |
  305|       |  // Clean bytes after the intended size of the copy.
  306|       |  // Example:
  307|       |  // new_ctrl = 1E01EEEEEEE????
  308|       |  // *new_ctrl= 1E0EEEEEEEE????
  309|       |  // position      /
  310|      6|  std::memset(new_ctrl + old_capacity_ + 1, static_cast<int8_t>(ctrl_t::kEmpty),
  311|      6|              kHalfWidth);
  312|       |  // Clean non-mirrored bytes that are not initialized.
  313|       |  // For small old_capacity that may be inside of mirrored bytes zone.
  314|       |  // Examples:
  315|       |  // new_ctrl = 1E0EEEEEEEE??????????....
  316|       |  // *new_ctrl= 1E0EEEEEEEEEEEEE?????....
  317|       |  // position           /
  318|       |  //
  319|       |  // new_ctrl = 456E0123???????????...
  320|       |  // *new_ctrl= 456E0123EEEEEEEE???...
  321|       |  // position           /
  322|      6|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  323|      6|              kHalfWidth);
  324|       |  // Clean last mirrored bytes that are not initialized
  325|       |  // and will not be overwritten by mirroring.
  326|       |  // Examples:
  327|       |  // new_ctrl = 1E0EEEEEEEEEEEEE????????
  328|       |  // *new_ctrl= 1E0EEEEEEEEEEEEEEEEEEEEE
  329|       |  // position           S       /
  330|       |  //
  331|       |  // new_ctrl = 456E0123EEEEEEEE???????????????
  332|       |  // *new_ctrl= 456E0123EEEEEEEE???????EEEEEEEE
  333|       |  // position                  S       /
  334|      6|  std::memset(new_ctrl + new_capacity + kHalfWidth,
  335|      6|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
  336|       |
  337|       |  // Create mirrored bytes. old_capacity_ < kHalfWidth
  338|       |  // Example:
  339|       |  // new_ctrl = 456E0123EEEEEEEE???????EEEEEEEE
  340|       |  // *new_ctrl= 456E0123EEEEEEEE456E0123EEEEEEE
  341|       |  // position                  S/
  342|      6|  ctrl_t g[kHalfWidth];
  343|      6|  std::memcpy(g, new_ctrl, kHalfWidth);
  344|      6|  std::memcpy(new_ctrl + new_capacity + 1, g, kHalfWidth);
  345|       |
  346|       |  // Finally set sentinel to its place.
  347|      6|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
  348|      6|}
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper43GrowIntoSingleGroupShuffleTransferableSlotsEPvS3_m:
  351|      6|    void* old_slots, void* new_slots, size_t slot_size) const {
  352|      6|  assert(old_capacity_ > 0);
  353|      6|  const size_t half_old_capacity = old_capacity_ / 2;
  354|       |
  355|      6|  SanitizerUnpoisonMemoryRegion(old_slots, slot_size * old_capacity_);
  356|      6|  std::memcpy(new_slots,
  357|      6|              SlotAddress(old_slots, half_old_capacity + 1, slot_size),
  358|      6|              slot_size * half_old_capacity);
  359|      6|  std::memcpy(SlotAddress(new_slots, half_old_capacity + 1, slot_size),
  360|      6|              old_slots, slot_size * (half_old_capacity + 1));
  361|      6|}
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper35GrowSizeIntoSingleGroupTransferableERNS1_12CommonFieldsEPvm:
  364|      6|    CommonFields& c, void* old_slots, size_t slot_size) {
  365|      6|  assert(old_capacity_ < Group::kWidth / 2);
  366|      6|  assert(is_single_group(c.capacity()));
  367|      6|  assert(IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity()));
  368|       |
  369|      6|  GrowIntoSingleGroupShuffleControlBytes(c.control(), c.capacity());
  370|      6|  GrowIntoSingleGroupShuffleTransferableSlots(old_slots, c.slot_array(),
  371|      6|                                              slot_size);
  372|       |
  373|       |  // We poison since GrowIntoSingleGroupShuffleTransferableSlots
  374|       |  // may leave empty slots unpoisoned.
  375|      6|  PoisonSingleGroupEmptySlots(c, slot_size);
  376|      6|}

_ZN4absl12lts_2024011618container_internal12CommonFieldsC2Ev:
 1028|      2|  CommonFields() = default;
_ZN4absl12lts_2024011618container_internal10EmptyGroupEv:
  521|      2|inline ctrl_t* EmptyGroup() {
  522|       |  // Const must be cast away here; no uses of this function will actually write
  523|       |  // to it, because it is only used for empty tables.
  524|      2|  return const_cast<ctrl_t*>(kEmptyGroup + 16);
  525|      2|}
_ZN4absl12lts_2024011618container_internal5probeERKNS1_12CommonFieldsEm:
 1420|     60|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1421|     60|  return probe(common.control(), common.capacity(), hash);
 1422|     60|}
_ZN4absl12lts_2024011618container_internal5probeEPKNS1_6ctrl_tEmm:
 1417|     60|                                      size_t hash) {
 1418|     60|  return probe_seq<Group::kWidth>(H1(hash, ctrl), capacity);
 1419|     60|}
_ZN4absl12lts_2024011618container_internal2H1EmPKNS1_6ctrl_tE:
  552|     60|inline size_t H1(size_t hash, const ctrl_t* ctrl) {
  553|     60|  return (hash >> 7) ^ PerTableSalt(ctrl);
  554|     60|}
_ZN4absl12lts_2024011618container_internal12PerTableSaltEPKNS1_6ctrl_tE:
  545|     60|inline size_t PerTableSalt(const ctrl_t* ctrl) {
  546|       |  // The low bits of the pointer have little or no entropy because of
  547|       |  // alignment. We shift the pointer to try to use higher entropy bits. A
  548|       |  // good number seems to be 12 bits, because that aligns with page size.
  549|     60|  return reinterpret_cast<uintptr_t>(ctrl) >> 12;
  550|     60|}
_ZN4absl12lts_2024011618container_internal9probe_seqILm16EEC2Emm:
  316|     60|  probe_seq(size_t hash, size_t mask) {
  317|       |    assert(((mask + 1) & mask) == 0 && "not a mask");
  318|     60|    mask_ = mask;
  319|     60|    offset_ = hash & mask_;
  320|     60|  }
_ZNK4absl12lts_2024011618container_internal12CommonFields7controlEv:
 1038|    410|  ctrl_t* control() const { return control_; }
_ZNK4absl12lts_2024011618container_internal12CommonFields8capacityEv:
 1065|    242|  size_t capacity() const { return capacity_; }
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEv:
  323|     60|  size_t offset() const { return offset_; }
_ZN4absl12lts_2024011618container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  615|     56|  explicit GroupSse2Impl(const ctrl_t* pos) {
  616|     56|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  617|     56|  }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl5MatchEh:
  620|     26|  BitMask<uint16_t, kWidth> Match(h2_t hash) const {
  621|     26|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  622|     26|    BitMask<uint16_t, kWidth> result = BitMask<uint16_t, kWidth>(0);
  623|     26|    result = BitMask<uint16_t, kWidth>(
  624|     26|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  625|     26|    return result;
  626|     26|  }
_ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEC2Et:
  437|     78|  explicit BitMask(T mask) : Base(mask) {}
_ZN4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EEC2Et:
  389|    130|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZN4absl12lts_2024011618container_internal2H2Em:
  559|     52|inline h2_t H2(size_t hash) { return hash & 0x7F; }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EE5beginEv:
  454|     26|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EE3endEv:
  455|     26|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2024011618container_internalneERKNS1_7BitMaskItLi16ELi0EEES5_:
  461|     27|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  462|     27|    return a.mask_ != b.mask_;
  463|     27|  }
_ZNK4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEdeEv:
  452|      1|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv:
  394|     27|  uint32_t LowestBitSet() const {
  395|     27|    return container_internal::TrailingZeros(mask_) >> Shift;
  396|     27|  }
_ZN4absl12lts_2024011618container_internal13TrailingZerosItEEjT_:
  372|     27|uint32_t TrailingZeros(T x) {
  373|     27|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  259|     27|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  374|     27|  return static_cast<uint32_t>(countr_zero(x));
  375|     27|}
_ZNK4absl12lts_2024011618container_internal12CommonFields10slot_arrayEv:
 1047|    137|  void* slot_array() const { return slots_; }
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE6offsetEm:
  324|     27|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZN4absl12lts_2024011618container_internal7BitMaskItLi16ELi0EEppEv:
  443|      1|  BitMask& operator++() {
  444|      1|    if (Shift == 3) {
  ------------------
  |  Branch (444:9): [Folded, False: 1]
  ------------------
  445|      0|      constexpr uint64_t msbs = 0x8080808080808080ULL;
  446|      0|      this->mask_ &= msbs;
  447|      0|    }
  448|      1|    this->mask_ &= (this->mask_ - 1);
  449|      1|    return *this;
  450|      1|  }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl9MaskEmptyEv:
  629|     26|  NonIterableBitMask<uint16_t, kWidth> MaskEmpty() const {
  630|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  631|       |    // This only works because ctrl_t::kEmpty is -128.
  632|       |    return NonIterableBitMask<uint16_t, kWidth>(
  633|       |        static_cast<uint16_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
  634|       |#else
  635|     26|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  636|     26|    return NonIterableBitMask<uint16_t, kWidth>(
  637|     26|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  638|     26|#endif
  639|     26|  }
_ZNK4absl12lts_2024011618container_internal18NonIterableBitMaskItLi16ELi0EEcvbEv:
  391|     52|  explicit operator bool() const { return this->mask_ != 0; }
_ZNK4absl12lts_2024011618container_internal12CommonFields41should_rehash_for_bug_detection_on_insertEv:
 1101|     26|  bool should_rehash_for_bug_detection_on_insert() const {
 1102|     26|    return CommonFieldsGenerationInfo::
 1103|     26|        should_rehash_for_bug_detection_on_insert(control(), capacity());
 1104|     26|  }
_ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled41should_rehash_for_bug_detection_on_insertEPKNS1_6ctrl_tEm:
  926|     26|  bool should_rehash_for_bug_detection_on_insert(const ctrl_t*, size_t) const {
  927|     26|    return false;
  928|     26|  }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelperC2ERNS1_12CommonFieldsE:
 1525|      8|      : old_ctrl_(c.control()),
 1526|      8|        old_capacity_(c.capacity()),
 1527|      8|        had_infoz_(c.has_infoz()) {}
_ZNK4absl12lts_2024011618container_internal12CommonFields9has_infozEv:
 1084|     42|  bool has_infoz() const {
 1085|     42|    return ABSL_PREDICT_FALSE((size_ & HasInfozMask()) != 0);
  ------------------
  |  |  178|     42|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:49): [Folded, False: 42]
  |  |  |  Branch (178:58): [True: 0, False: 42]
  |  |  ------------------
  ------------------
 1086|     42|  }
_ZN4absl12lts_2024011618container_internal12CommonFields12HasInfozMaskEv:
 1131|     44|  static constexpr size_t HasInfozMask() {
 1132|     44|    return (size_t{1} << HasInfozShift()) - 1;
 1133|     44|  }
_ZN4absl12lts_2024011618container_internal12CommonFields13HasInfozShiftEv:
 1130|    100|  static constexpr size_t HasInfozShift() { return 1; }
_ZN4absl12lts_2024011618container_internal12CommonFields12set_capacityEm:
 1066|      8|  void set_capacity(size_t c) {
 1067|       |    assert(c == 0 || IsValidCapacity(c));
 1068|      8|    capacity_ = c;
 1069|      8|  }
_ZN4absl12lts_2024011618container_internal12CommonFields5infozEv:
 1091|     34|  HashtablezInfoHandle infoz() {
 1092|     34|    return has_infoz()
  ------------------
  |  Branch (1092:12): [True: 0, False: 34]
  ------------------
 1093|     34|               ? *reinterpret_cast<HashtablezInfoHandle*>(backing_array_start())
 1094|     34|               : HashtablezInfoHandle();
 1095|     34|  }
_ZN4absl12lts_2024011618container_internal9AllocSizeEmmmb:
 1019|     14|                        bool has_infoz) {
 1020|     14|  return SlotOffset(capacity, slot_align, has_infoz) + capacity * slot_size;
 1021|     14|}
_ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  939|      8|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  942|      8|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2024011618container_internal16GenerationOffsetEmb:
 1001|     30|inline size_t GenerationOffset(size_t capacity, bool has_infoz) {
 1002|       |  assert(IsValidCapacity(capacity));
 1003|     30|  const size_t num_control_bytes = capacity + 1 + NumClonedBytes();
 1004|     30|  return ControlOffset(has_infoz) + num_control_bytes;
 1005|     30|}
_ZN4absl12lts_2024011618container_internal14NumClonedBytesEv:
  997|     86|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  940|      8|  void set_generation(GenerationType) {}
_ZN4absl12lts_2024011618container_internal14NextGenerationEh:
  254|      8|constexpr GenerationType NextGeneration(GenerationType generation) {
  255|      8|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (255:10): [True: 0, False: 8]
  ------------------
  256|      8|}
_ZN4absl12lts_2024011618container_internal23SentinelEmptyGenerationEv:
  252|      8|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2024011618container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
 1039|      8|  void set_control(ctrl_t* c) { control_ = c; }
_ZN4absl12lts_2024011618container_internal13ControlOffsetEb:
  988|     44|inline size_t ControlOffset(bool has_infoz) {
  989|     44|  return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(size_t);
  ------------------
  |  Branch (989:11): [True: 0, False: 44]
  ------------------
  990|     44|}
_ZN4absl12lts_2024011618container_internal12CommonFields9set_slotsEPv:
 1048|      8|  void set_slots(void* s) { slots_ = s; }
_ZN4absl12lts_2024011618container_internal10SlotOffsetEmmb:
 1009|     22|inline size_t SlotOffset(size_t capacity, size_t slot_align, bool has_infoz) {
 1010|       |  assert(IsValidCapacity(capacity));
 1011|     22|  return (GenerationOffset(capacity, has_infoz) + NumGenerationBytes() +
 1012|     22|          slot_align - 1) &
 1013|     22|         (~slot_align + 1);
 1014|     22|}
_ZN4absl12lts_2024011618container_internal18NumGenerationBytesEv:
  263|     22|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2024011618container_internal15ResetGrowthLeftERNS1_12CommonFieldsE:
 1464|     10|inline void ResetGrowthLeft(CommonFields& common) {
 1465|     10|  common.set_growth_left(CapacityToGrowth(common.capacity()) - common.size());
 1466|     10|}
_ZN4absl12lts_2024011618container_internal12CommonFields15set_growth_leftEm:
 1078|     36|  void set_growth_left(size_t gl) {
 1079|     36|    size_t* gl_ptr = reinterpret_cast<size_t*>(control()) - 1;
 1080|       |    assert(reinterpret_cast<uintptr_t>(gl_ptr) % alignof(size_t) == 0);
 1081|     36|    *gl_ptr = gl;
 1082|     36|  }
_ZN4absl12lts_2024011618container_internal16CapacityToGrowthEm:
 1197|     10|inline size_t CapacityToGrowth(size_t capacity) {
 1198|     10|  assert(IsValidCapacity(capacity));
 1199|       |  // `capacity*7/8`
 1200|     10|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (1200:7): [Folded, False: 10]
  |  Branch (1200:29): [True: 0, False: 0]
  ------------------
 1201|       |    // x-x/8 does not work when x==7.
 1202|      0|    return 6;
 1203|      0|  }
 1204|     10|  return capacity - capacity / 8;
 1205|     10|}
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper34IsGrowingIntoSingleGroupApplicableEmm:
 1686|     16|                                                 size_t new_capacity) {
 1687|       |    // NOTE that `old_capacity < new_capacity` in order to have
 1688|       |    // `old_capacity < Group::kWidth / 2` to make faster copies of 8 bytes.
 1689|     16|    return is_single_group(new_capacity) && old_capacity < new_capacity;
  ------------------
  |  Branch (1689:12): [True: 16, False: 0]
  |  Branch (1689:45): [True: 16, False: 0]
  ------------------
 1690|     16|  }
_ZN4absl12lts_2024011618container_internal15is_single_groupEm:
 1411|     16|inline bool is_single_group(size_t capacity) {
 1412|     16|  return capacity <= Group::kWidth;
 1413|     16|}
_ZN4absl12lts_2024011618container_internal9ResetCtrlERNS1_12CommonFieldsEm:
 1470|      4|inline void ResetCtrl(CommonFields& common, size_t slot_size) {
 1471|      4|  const size_t capacity = common.capacity();
 1472|      4|  ctrl_t* ctrl = common.control();
 1473|      4|  std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
 1474|      4|              capacity + 1 + NumClonedBytes());
 1475|      4|  ctrl[capacity] = ctrl_t::kSentinel;
 1476|      4|  SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity);
 1477|      4|}
_ZN4absl12lts_2024011618container_internal12CommonFields13set_has_infozEb:
 1087|      8|  void set_has_infoz(bool has_infoz) {
 1088|      8|    size_ = (size() << HasInfozShift()) | static_cast<size_t>(has_infoz);
 1089|      8|  }
_ZNK4absl12lts_2024011618container_internal12CommonFields4sizeEv:
 1051|     20|  size_t size() const { return size_ >> HasInfozShift(); }
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper12old_capacityEv:
 1557|      8|  size_t old_capacity() const { return old_capacity_; }
_ZNK4absl12lts_2024011618container_internal19HashSetResizeHelper27PoisonSingleGroupEmptySlotsERNS1_12CommonFieldsEm:
 1753|      6|  void PoisonSingleGroupEmptySlots(CommonFields& c, size_t slot_size) const {
 1754|       |    // poison non full items
 1755|     56|    for (size_t i = 0; i < c.capacity(); ++i) {
  ------------------
  |  Branch (1755:24): [True: 50, False: 6]
  ------------------
 1756|     50|      if (!IsFull(c.control()[i])) {
  ------------------
  |  Branch (1756:11): [True: 28, False: 22]
  ------------------
 1757|     28|        SanitizerPoisonMemoryRegion(SlotAddress(c.slot_array(), i, slot_size),
 1758|     28|                                    slot_size);
 1759|     28|      }
 1760|     50|    }
 1761|      6|  }
_ZN4absl12lts_2024011618container_internal11SlotAddressEPvmm:
 1513|     40|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
 1514|     40|  return reinterpret_cast<void*>(reinterpret_cast<char*>(slot_array) +
 1515|     40|                                 (slot * slot_size));
 1516|     40|}
_ZN4absl12lts_2024011618container_internal6IsFullENS1_6ctrl_tE:
  563|    106|inline bool IsFull(ctrl_t c) { return c >= static_cast<ctrl_t>(0); }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper13DeallocateOldILm8ENSt3__19allocatorIcEEEEvT0_mPv:
 1676|      6|  void DeallocateOld(CharAlloc alloc_ref, size_t slot_size, void* old_slots) {
 1677|      6|    SanitizerUnpoisonMemoryRegion(old_slots, slot_size * old_capacity_);
 1678|      6|    Deallocate<BackingArrayAlignment(AlignOfSlot)>(
 1679|      6|        &alloc_ref, old_ctrl_ - ControlOffset(had_infoz_),
 1680|      6|        AllocSize(old_capacity_, slot_size, AlignOfSlot, had_infoz_));
 1681|      6|  }
_ZNK4absl12lts_2024011618container_internal12CommonFields11growth_leftEv:
 1073|     52|  size_t growth_left() const {
 1074|     52|    const size_t* gl_ptr = reinterpret_cast<size_t*>(control()) - 1;
 1075|       |    assert(reinterpret_cast<uintptr_t>(gl_ptr) % alignof(size_t) == 0);
 1076|     52|    return *gl_ptr;
 1077|     52|  }
_ZN4absl12lts_2024011618container_internal12NextCapacityEm:
 1167|      8|inline size_t NextCapacity(size_t n) {
 1168|       |  assert(IsValidCapacity(n) || n == 0);
 1169|      8|  return n * 2 + 1;
 1170|      8|}
_ZN4absl12lts_2024011618container_internal19find_first_non_fullIvEENS1_8FindInfoERKNS1_12CommonFieldsEm:
 1432|     26|inline FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
 1433|     26|  auto seq = probe(common, hash);
 1434|     26|  const ctrl_t* ctrl = common.control();
 1435|     26|  while (true) {
  ------------------
  |  Branch (1435:10): [True: 26, Folded]
  ------------------
 1436|     26|    GroupEmptyOrDeleted g{ctrl + seq.offset()};
 1437|     26|    auto mask = g.MaskEmptyOrDeleted();
 1438|     26|    if (mask) {
  ------------------
  |  Branch (1438:9): [True: 26, False: 0]
  ------------------
 1439|       |#if !defined(NDEBUG)
 1440|       |      // We want to add entropy even when ASLR is not enabled.
 1441|       |      // In debug build we will randomly insert in either the front or back of
 1442|       |      // the group.
 1443|       |      // TODO(kfm,sbenza): revisit after we do unconditional mixing
 1444|       |      if (!is_small(common.capacity()) && ShouldInsertBackwards(hash, ctrl)) {
 1445|       |        return {seq.offset(mask.HighestBitSet()), seq.index()};
 1446|       |      }
 1447|       |#endif
 1448|     26|      return {seq.offset(mask.LowestBitSet()), seq.index()};
 1449|     26|    }
 1450|      0|    seq.next();
 1451|       |    assert(seq.index() <= common.capacity() && "full table!");
 1452|      0|  }
 1453|     26|}
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  650|     26|  NonIterableBitMask<uint16_t, kWidth> MaskEmptyOrDeleted() const {
  651|     26|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  652|     26|    return NonIterableBitMask<uint16_t, kWidth>(static_cast<uint16_t>(
  653|     26|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  654|     26|  }
_ZN4absl12lts_2024011618container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  601|     30|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  602|       |#if defined(__GNUC__) && !defined(__clang__)
  603|       |  if (std::is_unsigned<char>::value) {
  604|       |    const __m128i mask = _mm_set1_epi8(0x80);
  605|       |    const __m128i diff = _mm_subs_epi8(b, a);
  606|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  607|       |  }
  608|       |#endif
  609|     30|  return _mm_cmpgt_epi8(a, b);
  610|     30|}
_ZNK4absl12lts_2024011618container_internal9probe_seqILm16EE5indexEv:
  332|     26|  size_t index() const { return index_; }
_ZN4absl12lts_2024011618container_internal9IsDeletedENS1_6ctrl_tE:
  564|      8|inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper27FindFirstNonFullAfterResizeERKNS1_12CommonFieldsEmm:
 1537|      8|                                              size_t hash) {
 1538|      8|    if (!IsGrowingIntoSingleGroupApplicable(old_capacity, c.capacity())) {
  ------------------
  |  Branch (1538:9): [True: 0, False: 8]
  ------------------
 1539|      0|      return find_first_non_full(c, hash);
 1540|      0|    }
 1541|       |    // Find a location for the new element non-deterministically.
 1542|       |    // Note that any position is correct.
 1543|       |    // It will located at `half_old_capacity` or one of the other
 1544|       |    // empty slots with approximately 50% probability each.
 1545|      8|    size_t offset = probe(c, hash).offset();
 1546|       |
 1547|       |    // Note that we intentionally use unsigned int underflow.
 1548|      8|    if (offset - (old_capacity + 1) >= old_capacity) {
  ------------------
  |  Branch (1548:9): [True: 4, False: 4]
  ------------------
 1549|       |      // Offset fall on kSentinel or into the mostly occupied first half.
 1550|      4|      offset = old_capacity / 2;
 1551|      4|    }
 1552|       |    assert(IsEmpty(c.control()[offset]));
 1553|      8|    return FindInfo{offset, 0};
 1554|      8|  }
_ZN4absl12lts_2024011618container_internal12CommonFields14increment_sizeEv:
 1055|     26|  void increment_size() {
 1056|       |    assert(size() < capacity());
 1057|     26|    size_ += size_t{1} << HasInfozShift();
 1058|     26|  }
_ZN4absl12lts_2024011618container_internal7IsEmptyENS1_6ctrl_tE:
  562|     26|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
_ZN4absl12lts_2024011618container_internal7SetCtrlERKNS1_12CommonFieldsEmhm:
 1502|     26|                    size_t slot_size) {
 1503|     26|  SetCtrl(common, i, static_cast<ctrl_t>(h), slot_size);
 1504|     26|}
_ZN4absl12lts_2024011618container_internal7SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
 1484|     26|                    size_t slot_size) {
 1485|     26|  const size_t capacity = common.capacity();
 1486|     26|  assert(i < capacity);
 1487|       |
 1488|     26|  auto* slot_i = static_cast<const char*>(common.slot_array()) + i * slot_size;
 1489|     26|  if (IsFull(h)) {
  ------------------
  |  Branch (1489:7): [True: 26, False: 0]
  ------------------
 1490|     26|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
 1491|     26|  } else {
 1492|      0|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
 1493|      0|  }
 1494|       |
 1495|     26|  ctrl_t* ctrl = common.control();
 1496|     26|  ctrl[i] = h;
 1497|     26|  ctrl[((i - NumClonedBytes()) & capacity) + (NumClonedBytes() & capacity)] = h;
 1498|     26|}
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  932|     26|  void maybe_increment_generation_on_insert() {}
_ZNK4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  941|     30|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  965|     30|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZN4absl12lts_2024011618container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  565|     32|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZNK4absl12lts_2024011618container_internal13GroupSse2Impl26CountLeadingEmptyOrDeletedEv:
  657|      4|  uint32_t CountLeadingEmptyOrDeleted() const {
  658|      4|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  659|      4|    return TrailingZeros(static_cast<uint32_t>(
  660|      4|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl)) + 1));
  661|      4|  }
_ZN4absl12lts_2024011618container_internal13TrailingZerosIjEEjT_:
  372|      4|uint32_t TrailingZeros(T x) {
  373|      4|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  259|      4|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  374|      4|  return static_cast<uint32_t>(countr_zero(x));
  375|      4|}
_ZN4absl12lts_2024011618container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh:
 1290|     56|                                       const GenerationType* generation_ptr) {
 1291|     56|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1291:7): [True: 56, Folded]
  ------------------
 1292|      0|  const bool ctrl_is_valid_for_comparison =
 1293|      0|      ctrl == nullptr || ctrl == EmptyGroup() || IsFull(*ctrl);
  ------------------
  |  Branch (1293:7): [True: 0, False: 0]
  |  Branch (1293:26): [True: 0, False: 0]
  |  Branch (1293:50): [True: 0, False: 0]
  ------------------
 1294|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1294:7): [Folded, False: 0]
  ------------------
 1295|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1296|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1297|      0|                   "Invalid iterator comparison. The table could have rehashed "
 1298|      0|                   "or moved since this iterator was initialized.");
 1299|      0|    }
 1300|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1301|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1302|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1303|      0|    }
 1304|      0|  } else {
 1305|      0|    ABSL_HARDENING_ASSERT(
  ------------------
  |  |  128|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1306|      0|        ctrl_is_valid_for_comparison &&
 1307|      0|        "Invalid iterator comparison. The element might have been erased or "
 1308|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1309|      0|        "diagnose rehashing issues.");
 1310|      0|  }
 1311|      0|}
_ZNK4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  967|    108|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2024011618container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  969|    164|  const GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2024011618container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_:
 1339|     28|                                const GenerationType* generation_ptr_b) {
 1340|     28|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1340:7): [True: 28, Folded]
  ------------------
 1341|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1342|       |  // enabled. To minimize their impact in those builds:
 1343|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1344|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1345|       |  //   the chances that the hot paths will be inlined.
 1346|      0|  const bool a_is_default = ctrl_a == EmptyGroup();
 1347|      0|  const bool b_is_default = ctrl_b == EmptyGroup();
 1348|      0|  if (ABSL_PREDICT_FALSE(a_is_default != b_is_default)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1349|      0|    ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1350|      0|        FATAL,
 1351|      0|        "Invalid iterator comparison. Comparing default-constructed iterator "
 1352|      0|        "with non-default-constructed iterator.");
 1353|      0|  }
 1354|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1354:7): [True: 0, False: 0]
  |  Branch (1354:23): [True: 0, False: 0]
  ------------------
 1355|       |
 1356|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1356:7): [Folded, False: 0]
  ------------------
 1357|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  179|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 0, False: 0]
  |  |  |  Branch (179:48): [Folded, False: 0]
  |  |  |  Branch (179:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1358|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1359|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1360|      0|    if (a_is_empty != b_is_empty) {
  ------------------
  |  Branch (1360:9): [True: 0, False: 0]
  ------------------
 1361|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1362|      0|                   "Invalid iterator comparison. Comparing iterator from a "
 1363|      0|                   "non-empty hashtable with an iterator from an empty "
 1364|      0|                   "hashtable.");
 1365|      0|    }
 1366|      0|    if (a_is_empty && b_is_empty) {
  ------------------
  |  Branch (1366:9): [True: 0, False: 0]
  |  Branch (1366:23): [True: 0, False: 0]
  ------------------
 1367|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1368|      0|                   "Invalid iterator comparison. Comparing iterators from "
 1369|      0|                   "different empty hashtables.");
 1370|      0|    }
 1371|      0|    const bool a_is_end = ctrl_a == nullptr;
 1372|      0|    const bool b_is_end = ctrl_b == nullptr;
 1373|      0|    if (a_is_end || b_is_end) {
  ------------------
  |  Branch (1373:9): [True: 0, False: 0]
  |  Branch (1373:21): [True: 0, False: 0]
  ------------------
 1374|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1375|      0|                   "Invalid iterator comparison. Comparing iterator with an "
 1376|      0|                   "end() iterator from a different hashtable.");
 1377|      0|    }
 1378|      0|    ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1379|      0|                 "Invalid iterator comparison. Comparing non-end() iterators "
 1380|      0|                 "from different hashtables.");
 1381|      0|  } else {
 1382|      0|    ABSL_HARDENING_ASSERT(
  ------------------
  |  |  128|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (95:4): [Folded, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, False: 0]
  |  |  |  |  |  Branch (95:30): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1383|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1384|      0|        "Invalid iterator comparison. The iterators may be from different "
 1385|      0|        "containers or the container might have rehashed or moved. Consider "
 1386|      0|        "running with --config=asan to diagnose issues.");
 1387|      0|  }
 1388|      0|}
_ZN4absl12lts_2024011618container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1248|     52|                         const char* operation) {
 1249|     52|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1249:7): [True: 52, Folded]
  ------------------
 1250|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1251|       |  // enabled. To minimize their impact in those builds:
 1252|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1253|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1254|       |  //   the chances that the hot paths will be inlined.
 1255|      0|  if (ABSL_PREDICT_FALSE(ctrl == nullptr)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1256|      0|    ABSL_RAW_LOG(FATAL, "%s called on end() iterator.", operation);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1257|      0|  }
 1258|      0|  if (ABSL_PREDICT_FALSE(ctrl == EmptyGroup())) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1259|      0|    ABSL_RAW_LOG(FATAL, "%s called on default-constructed iterator.",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1260|      0|                 operation);
 1261|      0|  }
 1262|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1262:7): [Folded, False: 0]
  ------------------
 1263|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1264|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1265|      0|                   "%s called on invalid iterator. The table could have "
 1266|      0|                   "rehashed or moved since this iterator was initialized.",
 1267|      0|                   operation);
 1268|      0|    }
 1269|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1270|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1271|      0|          FATAL,
 1272|      0|          "%s called on invalid iterator. The element was likely erased.",
 1273|      0|          operation);
 1274|      0|    }
 1275|      0|  } else {
 1276|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1277|       |      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1278|      0|          FATAL,
 1279|      0|          "%s called on invalid iterator. The element might have been erased "
 1280|      0|          "or the table might have rehashed. Consider running with "
 1281|      0|          "--config=asan to diagnose rehashing issues.",
 1282|      0|          operation);
 1283|      0|    }
 1284|      0|  }
 1285|      0|}
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  936|      2|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2024011618container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  938|      2|  void set_reservation_size(size_t) {}
_ZN4absl12lts_2024011618container_internal12CommonFields8set_sizeEm:
 1052|      2|  void set_size(size_t s) {
 1053|      2|    size_ = (s << HasInfozShift()) | (size_ & HasInfozMask());
 1054|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5beginEv:
 2266|      2|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2267|      2|    auto it = iterator_at(0);
 2268|      2|    it.skip_empty_or_deleted();
 2269|      2|    return it;
 2270|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11iterator_atEm:
 3159|     28|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3160|     28|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3161|     28|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7controlEv:
 3196|    116|  ctrl_t* control() const { return common().control(); }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6commonEv:
 3194|    255|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE10slot_arrayEv:
 3197|     65|  slot_type* slot_array() const {
 3198|     65|    return static_cast<slot_type*>(common().slot_array());
 3199|     65|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6commonEv:
 3193|    276|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_SA_EEPKh:
 1984|     28|        : HashSetIteratorGenerationInfo(generation_ptr),
 1985|     28|          ctrl_(ctrl),
 1986|     28|          slot_(slot) {
 1987|       |      // This assumption helps the compiler know that any non-end iterator is
 1988|       |      // not equal to any end iterator.
 1989|     28|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  259|     28|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1990|     28|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iterator21skip_empty_or_deletedEv:
 1999|     28|    void skip_empty_or_deleted() {
 2000|     32|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2000:14): [True: 4, False: 28]
  ------------------
 2001|      4|        uint32_t shift =
 2002|      4|            GroupEmptyOrDeleted{ctrl_}.CountLeadingEmptyOrDeleted();
 2003|      4|        ctrl_ += shift;
 2004|      4|        slot_ += shift;
 2005|      4|      }
 2006|     28|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  178|     28|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 2, False: 26]
  |  |  |  Branch (178:49): [Folded, False: 28]
  |  |  |  Branch (178:58): [True: 2, False: 26]
  |  |  ------------------
  ------------------
 2007|     28|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE3endEv:
 2271|      2|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2272|      2|    return iterator(common().generation_ptr());
 2273|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorC2EPKh:
 1993|      2|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2024011618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorESM_:
 1977|     28|    friend bool operator!=(const iterator& a, const iterator& b) {
 1978|     28|      return !(a == b);
 1979|     28|    }
_ZN4absl12lts_2024011618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorESM_:
 1970|     28|    friend bool operator==(const iterator& a, const iterator& b) {
 1971|     28|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1972|     28|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1973|     28|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1974|     28|                          a.generation_ptr(), b.generation_ptr());
 1975|     28|      return a.ctrl_ == b.ctrl_;
 1976|     28|    }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratordeEv:
 1944|     26|    reference operator*() const {
 1945|     26|      AssertIsFull(ctrl_, generation(), generation_ptr(), "operator*()");
 1946|     26|      return unchecked_deref();
 1947|     26|    }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iterator15unchecked_derefEv:
 2029|     26|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8iteratorppEv:
 1956|     26|    iterator& operator++() {
 1957|     26|      AssertIsFull(ctrl_, generation(), generation_ptr(), "operator++");
 1958|     26|      ++ctrl_;
 1959|     26|      ++slot_;
 1960|     26|      skip_empty_or_deleted();
 1961|     26|      return *this;
 1962|     26|    }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8capacityEv:
 2288|     20|  size_t capacity() const { return common().capacity(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE13destroy_slotsEv:
 2861|      2|  inline void destroy_slots() {
 2862|      2|    const size_t cap = capacity();
 2863|      2|    const ctrl_t* ctrl = control();
 2864|      2|    slot_type* slot = slot_array();
 2865|     32|    for (size_t i = 0; i != cap; ++i) {
  ------------------
  |  Branch (2865:24): [True: 30, False: 2]
  ------------------
 2866|     30|      if (IsFull(ctrl[i])) {
  ------------------
  |  Branch (2866:11): [True: 26, False: 4]
  ------------------
 2867|     26|        destroy(slot + i);
 2868|     26|      }
 2869|     30|    }
 2870|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7destroyEPNS1_13map_slot_typeIS8_SA_EE:
 2854|     26|  inline void destroy(slot_type* slot) {
 2855|     26|    PolicyTraits::destroy(&alloc_ref(), slot);
 2856|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE9alloc_refEv:
 3206|     60|  allocator_type& alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5infozEv:
 3200|     26|  HashtablezInfoHandle infoz() { return common().infoz(); }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19prefetch_heap_blockEv:
 3187|     26|  void prefetch_heap_block() const {
 3188|     26|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3189|     26|    __builtin_prefetch(control(), 0, 1);
 3190|     26|#endif
 3191|     26|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE12EqualElementIS8_EclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJRSG_EEENSQ_IJRKSA_EEEEEEbRKT_DpOT0_:
 2813|      1|    bool operator()(const K2& lhs, Args&&...) const {
 2814|      1|      return eq(lhs, rhs);
 2815|      1|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6eq_refEv:
 3204|      1|  key_equal& eq_ref() { return settings_.template get<2>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE8hash_refEv:
 3202|     26|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6insertISH_TnNS4_9enable_ifIXsr4absl11disjunctionINS4_14is_convertibleIT_NSF_IS8_SA_EEEENSJ_22SameAsElementReferenceISN_EEEE5valueEiE4typeELi0ESH_TnNSL_IXsr14IsDecomposableIT1_EE5valueEiE4typeELi0ETnPSN_LPSH_0EEENSF_INSJ_8iteratorEbEEOSN_:
 2320|     26|  std::pair<iterator, bool> insert(T&& value) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2321|     26|    return emplace(std::forward<T>(value));
 2322|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE7emplaceIJSH_ETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSF_INSJ_8iteratorEbEEDpOSM_:
 2422|     26|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2423|     26|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2424|     26|                               std::forward<Args>(args)...);
 2425|     26|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE19EmplaceDecomposableclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSP_IJOSA_EEEEEENSF_INSJ_8iteratorEbEERKT_DpOT0_:
 2822|     26|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2823|     26|      auto res = s.find_or_prepare_insert(key);
 2824|     26|      if (res.second) {
  ------------------
  |  Branch (2824:11): [True: 26, False: 0]
  ------------------
 2825|     26|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2826|     26|      }
 2827|     26|      return {s.iterator_at(res.first), res.second};
 2828|     26|    }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE22find_or_prepare_insertIS8_EENSF_ImbEERKT_:
 3086|     26|  std::pair<size_t, bool> find_or_prepare_insert(const K& key) {
 3087|     26|    prefetch_heap_block();
 3088|     26|    auto hash = hash_ref()(key);
 3089|     26|    auto seq = probe(common(), hash);
 3090|     26|    const ctrl_t* ctrl = control();
 3091|     26|    while (true) {
  ------------------
  |  Branch (3091:12): [True: 26, Folded]
  ------------------
 3092|     26|      Group g{ctrl + seq.offset()};
 3093|     26|      for (uint32_t i : g.Match(H2(hash))) {
  ------------------
  |  Branch (3093:23): [True: 1, False: 26]
  ------------------
 3094|      1|        if (ABSL_PREDICT_TRUE(PolicyTraits::apply(
  ------------------
  |  |  179|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 0, False: 1]
  |  |  |  Branch (179:48): [Folded, False: 1]
  |  |  |  Branch (179:57): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 3095|      1|                EqualElement<K>{key, eq_ref()},
 3096|      1|                PolicyTraits::element(slot_array() + seq.offset(i)))))
 3097|      0|          return {seq.offset(i), false};
 3098|      1|      }
 3099|     26|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) break;
  ------------------
  |  |  179|     26|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 26, False: 0]
  |  |  |  Branch (179:48): [Folded, False: 26]
  |  |  |  Branch (179:57): [True: 26, False: 0]
  |  |  ------------------
  ------------------
 3100|      0|      seq.next();
 3101|      0|      assert(seq.index() <= capacity() && "full table!");
 3102|      0|    }
 3103|     26|    return {prepare_insert(hash), true};
 3104|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE14prepare_insertEm:
 3110|     26|  size_t prepare_insert(size_t hash) ABSL_ATTRIBUTE_NOINLINE {
 3111|     26|    const bool rehash_for_bug_detection =
 3112|     26|        common().should_rehash_for_bug_detection_on_insert();
 3113|     26|    if (rehash_for_bug_detection) {
  ------------------
  |  Branch (3113:9): [True: 0, False: 26]
  ------------------
 3114|       |      // Move to a different heap allocation in order to detect bugs.
 3115|      0|      const size_t cap = capacity();
 3116|      0|      resize(growth_left() > 0 ? cap : NextCapacity(cap));
  ------------------
  |  Branch (3116:14): [True: 0, False: 0]
  ------------------
 3117|      0|    }
 3118|     26|    auto target = find_first_non_full(common(), hash);
 3119|     26|    if (!rehash_for_bug_detection &&
  ------------------
  |  Branch (3119:9): [True: 26, False: 0]
  ------------------
 3120|     26|        ABSL_PREDICT_FALSE(growth_left() == 0 &&
  ------------------
  |  |  178|     34|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 8, False: 18]
  |  |  |  Branch (178:49): [Folded, False: 26]
  |  |  |  Branch (178:59): [True: 8, False: 18]
  |  |  |  Branch (178:59): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 3121|     26|                           !IsDeleted(control()[target.offset]))) {
 3122|      8|      size_t old_capacity = capacity();
 3123|      8|      rehash_and_grow_if_necessary();
 3124|       |      // NOTE: It is safe to use `FindFirstNonFullAfterResize`.
 3125|       |      // `FindFirstNonFullAfterResize` must be called right after resize.
 3126|       |      // `rehash_and_grow_if_necessary` may *not* call `resize`
 3127|       |      // and perform `drop_deletes_without_resize` instead. But this
 3128|       |      // could happen only on big tables.
 3129|       |      // For big tables `FindFirstNonFullAfterResize` will always
 3130|       |      // fallback to normal `find_first_non_full`, so it is safe to use it.
 3131|      8|      target = HashSetResizeHelper::FindFirstNonFullAfterResize(
 3132|      8|          common(), old_capacity, hash);
 3133|      8|    }
 3134|     26|    common().increment_size();
 3135|     26|    set_growth_left(growth_left() - IsEmpty(control()[target.offset]));
 3136|     26|    SetCtrl(common(), target.offset, H2(hash), sizeof(slot_type));
 3137|     26|    common().maybe_increment_generation_on_insert();
 3138|     26|    infoz().RecordInsert(hash, target.probe_length);
 3139|     26|    return target.offset;
 3140|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE6resizeEm:
 2905|      8|  ABSL_ATTRIBUTE_NOINLINE void resize(size_t new_capacity) {
 2906|      8|    assert(IsValidCapacity(new_capacity));
 2907|      8|    HashSetResizeHelper resize_helper(common());
 2908|      8|    auto* old_slots = slot_array();
 2909|      8|    common().set_capacity(new_capacity);
 2910|       |    // Note that `InitializeSlots` does different number initialization steps
 2911|       |    // depending on the values of `transfer_uses_memcpy` and capacities.
 2912|       |    // Refer to the comment in `InitializeSlots` for more details.
 2913|      8|    const bool grow_single_group =
 2914|      8|        resize_helper.InitializeSlots<CharAlloc, sizeof(slot_type),
 2915|      8|                                      PolicyTraits::transfer_uses_memcpy(),
 2916|      8|                                      alignof(slot_type)>(
 2917|      8|            common(), const_cast<std::remove_const_t<slot_type>*>(old_slots),
 2918|      8|            CharAlloc(alloc_ref()));
 2919|       |
 2920|      8|    if (resize_helper.old_capacity() == 0) {
  ------------------
  |  Branch (2920:9): [True: 2, False: 6]
  ------------------
 2921|       |      // InitializeSlots did all the work including infoz().RecordRehash().
 2922|      2|      return;
 2923|      2|    }
 2924|       |
 2925|      6|    if (grow_single_group) {
  ------------------
  |  Branch (2925:9): [True: 6, False: 0]
  ------------------
 2926|      6|      if (PolicyTraits::transfer_uses_memcpy()) {
  ------------------
  |  Branch (2926:11): [True: 6, Folded]
  ------------------
 2927|       |        // InitializeSlots did all the work.
 2928|      6|        return;
 2929|      6|      }
 2930|       |      // We want GrowSizeIntoSingleGroup to be called here in order to make
 2931|       |      // InitializeSlots not depend on PolicyTraits.
 2932|      0|      resize_helper.GrowSizeIntoSingleGroup<PolicyTraits>(common(), alloc_ref(),
 2933|      0|                                                          old_slots);
 2934|      0|    } else {
 2935|       |      // InitializeSlots prepares control bytes to correspond to empty table.
 2936|      0|      auto* new_slots = slot_array();
 2937|      0|      size_t total_probe_length = 0;
 2938|      0|      for (size_t i = 0; i != resize_helper.old_capacity(); ++i) {
  ------------------
  |  Branch (2938:26): [True: 0, False: 0]
  ------------------
 2939|      0|        if (IsFull(resize_helper.old_ctrl()[i])) {
  ------------------
  |  Branch (2939:13): [True: 0, False: 0]
  ------------------
 2940|      0|          size_t hash = PolicyTraits::apply(
 2941|      0|              HashElement{hash_ref()}, PolicyTraits::element(old_slots + i));
 2942|      0|          auto target = find_first_non_full(common(), hash);
 2943|      0|          size_t new_i = target.offset;
 2944|      0|          total_probe_length += target.probe_length;
 2945|      0|          SetCtrl(common(), new_i, H2(hash), sizeof(slot_type));
 2946|      0|          transfer(new_slots + new_i, old_slots + i);
 2947|      0|        }
 2948|      0|      }
 2949|      0|      infoz().RecordRehash(total_probe_length);
 2950|      0|    }
 2951|      0|    resize_helper.DeallocateOld<alignof(slot_type)>(
 2952|      0|        CharAlloc(alloc_ref()), sizeof(slot_type),
 2953|      0|        const_cast<std::remove_const_t<slot_type>*>(old_slots));
 2954|      0|  }
_ZN4absl12lts_2024011618container_internal19HashSetResizeHelper15InitializeSlotsINSt3__19allocatorIcEELm24ELb1ELm8EEEbRNS1_12CommonFieldsEPvT_:
 1595|      8|                                               Alloc alloc) {
 1596|      8|    assert(c.capacity());
 1597|       |    // Folks with custom allocators often make unwarranted assumptions about the
 1598|       |    // behavior of their classes vis-a-vis trivial destructability and what
 1599|       |    // calls they will or won't make.  Avoid sampling for people with custom
 1600|       |    // allocators to get us out of this mess.  This is not a hard guarantee but
 1601|       |    // a workaround while we plan the exact guarantee we want to provide.
 1602|      8|    const size_t sample_size =
 1603|      8|        (std::is_same<Alloc, std::allocator<char>>::value &&
  ------------------
  |  Branch (1603:10): [True: 8, Folded]
  ------------------
 1604|      8|         c.slot_array() == nullptr)
  ------------------
  |  Branch (1604:10): [True: 2, False: 6]
  ------------------
 1605|      8|            ? SizeOfSlot
 1606|      8|            : 0;
 1607|      8|    HashtablezInfoHandle infoz =
 1608|      8|        sample_size > 0 ? Sample(sample_size) : c.infoz();
  ------------------
  |  Branch (1608:9): [True: 2, False: 6]
  ------------------
 1609|       |
 1610|      8|    const bool has_infoz = infoz.IsSampled();
 1611|      8|    const size_t cap = c.capacity();
 1612|      8|    const size_t alloc_size =
 1613|      8|        AllocSize(cap, SizeOfSlot, AlignOfSlot, has_infoz);
 1614|      8|    char* mem = static_cast<char*>(
 1615|      8|        Allocate<BackingArrayAlignment(AlignOfSlot)>(&alloc, alloc_size));
 1616|      8|    const GenerationType old_generation = c.generation();
 1617|      8|    c.set_generation_ptr(reinterpret_cast<GenerationType*>(
 1618|      8|        mem + GenerationOffset(cap, has_infoz)));
 1619|      8|    c.set_generation(NextGeneration(old_generation));
 1620|      8|    c.set_control(reinterpret_cast<ctrl_t*>(mem + ControlOffset(has_infoz)));
 1621|      8|    c.set_slots(mem + SlotOffset(cap, AlignOfSlot, has_infoz));
 1622|      8|    ResetGrowthLeft(c);
 1623|       |
 1624|      8|    const bool grow_single_group =
 1625|      8|        IsGrowingIntoSingleGroupApplicable(old_capacity_, c.capacity());
 1626|      8|    if (old_capacity_ != 0 && grow_single_group) {
  ------------------
  |  Branch (1626:9): [True: 6, False: 2]
  |  Branch (1626:31): [True: 6, False: 0]
  ------------------
 1627|      6|      if (TransferUsesMemcpy) {
  ------------------
  |  Branch (1627:11): [True: 6, Folded]
  ------------------
 1628|      6|        GrowSizeIntoSingleGroupTransferable(c, old_slots, SizeOfSlot);
 1629|      6|        DeallocateOld<AlignOfSlot>(alloc, SizeOfSlot, old_slots);
 1630|      6|      } else {
 1631|      0|        GrowIntoSingleGroupShuffleControlBytes(c.control(), c.capacity());
 1632|      0|      }
 1633|      6|    } else {
 1634|      2|      ResetCtrl(c, SizeOfSlot);
 1635|      2|    }
 1636|       |
 1637|      8|    c.set_has_infoz(has_infoz);
 1638|      8|    if (has_infoz) {
  ------------------
  |  Branch (1638:9): [True: 0, False: 8]
  ------------------
 1639|      0|      infoz.RecordStorageChanged(c.size(), cap);
 1640|      0|      if (grow_single_group || old_capacity_ == 0) {
  ------------------
  |  Branch (1640:11): [True: 0, False: 0]
  |  Branch (1640:32): [True: 0, False: 0]
  ------------------
 1641|      0|        infoz.RecordRehash(0);
 1642|      0|      }
 1643|      0|      c.set_infoz(infoz);
 1644|      0|    }
 1645|      8|    return grow_single_group;
 1646|      8|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE11growth_leftEv:
 3181|     52|  size_t growth_left() const { return common().growth_left(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE28rehash_and_grow_if_necessaryEv:
 2970|      8|  void rehash_and_grow_if_necessary() {
 2971|      8|    const size_t cap = capacity();
 2972|      8|    if (cap > Group::kWidth &&
  ------------------
  |  Branch (2972:9): [True: 0, False: 8]
  ------------------
 2973|       |        // Do these calculations in 64-bit to avoid overflow.
 2974|      0|        size() * uint64_t{32} <= cap * uint64_t{25}) {
  ------------------
  |  Branch (2974:9): [True: 0, False: 0]
  ------------------
 2975|       |      // Squash DELETED without growing if there is enough capacity.
 2976|       |      //
 2977|       |      // Rehash in place if the current size is <= 25/32 of capacity.
 2978|       |      // Rationale for such a high factor: 1) drop_deletes_without_resize() is
 2979|       |      // faster than resize, and 2) it takes quite a bit of work to add
 2980|       |      // tombstones.  In the worst case, seems to take approximately 4
 2981|       |      // insert/erase pairs to create a single tombstone and so if we are
 2982|       |      // rehashing because of tombstones, we can afford to rehash-in-place as
 2983|       |      // long as we are reclaiming at least 1/8 the capacity without doing more
 2984|       |      // than 2X the work.  (Where "work" is defined to be size() for rehashing
 2985|       |      // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
 2986|       |      // place is faster per operation than inserting or even doubling the size
 2987|       |      // of the table, so we actually afford to reclaim even less space from a
 2988|       |      // resize-in-place.  The decision is to rehash in place if we can reclaim
 2989|       |      // at about 1/8th of the usable capacity (specifically 3/28 of the
 2990|       |      // capacity) which means that the total cost of rehashing will be a small
 2991|       |      // fraction of the total work.
 2992|       |      //
 2993|       |      // Here is output of an experiment using the BM_CacheInSteadyState
 2994|       |      // benchmark running the old case (where we rehash-in-place only if we can
 2995|       |      // reclaim at least 7/16*capacity) vs. this code (which rehashes in place
 2996|       |      // if we can recover 3/32*capacity).
 2997|       |      //
 2998|       |      // Note that although in the worst-case number of rehashes jumped up from
 2999|       |      // 15 to 190, but the number of operations per second is almost the same.
 3000|       |      //
 3001|       |      // Abridged output of running BM_CacheInSteadyState benchmark from
 3002|       |      // raw_hash_set_benchmark.   N is the number of insert/erase operations.
 3003|       |      //
 3004|       |      //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
 3005|       |      // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
 3006|       |      //  448 | 145284       0.44        18 | 140118       0.44        19
 3007|       |      //  493 | 152546       0.24        11 | 151417       0.48        28
 3008|       |      //  538 | 151439       0.26        11 | 151152       0.53        38
 3009|       |      //  583 | 151765       0.28        11 | 150572       0.57        50
 3010|       |      //  628 | 150241       0.31        11 | 150853       0.61        66
 3011|       |      //  672 | 149602       0.33        12 | 150110       0.66        90
 3012|       |      //  717 | 149998       0.35        12 | 149531       0.70       129
 3013|       |      //  762 | 149836       0.37        13 | 148559       0.74       190
 3014|       |      //  807 | 149736       0.39        14 | 151107       0.39        14
 3015|       |      //  852 | 150204       0.42        15 | 151019       0.42        15
 3016|      0|      drop_deletes_without_resize();
 3017|      8|    } else {
 3018|       |      // Otherwise grow the container.
 3019|      8|      resize(NextCapacity(cap));
 3020|      8|    }
 3021|      8|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE18GetPolicyFunctionsEv:
 3236|      2|  static const PolicyFunctions& GetPolicyFunctions() {
 3237|      2|    static constexpr PolicyFunctions value = {
 3238|      2|        sizeof(slot_type),
 3239|      2|        &raw_hash_set::hash_slot_fn,
 3240|      2|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3240:9): [True: 0, Folded]
  ------------------
 3241|      2|            ? TransferRelocatable<sizeof(slot_type)>
 3242|      2|            : &raw_hash_set::transfer_slot_fn,
 3243|      2|        (std::is_same<SlotAlloc, std::allocator<slot_type>>::value
  ------------------
  |  Branch (3243:10): [True: 0, Folded]
  ------------------
 3244|      2|             ? &DeallocateStandard<alignof(slot_type)>
 3245|      2|             : &raw_hash_set::dealloc_fn),
 3246|      2|    };
 3247|      2|    return value;
 3248|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE15set_growth_leftEm:
 3182|     26|  void set_growth_left(size_t gl) { return common().set_growth_left(gl); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSO_IJOSA_EEEEEEvmDpOT_:
 3151|     26|  void emplace_at(size_t i, Args&&... args) {
 3152|     26|    construct(slot_array() + i, std::forward<Args>(args)...);
 3153|       |
 3154|       |    assert(PolicyTraits::apply(FindElement{*this}, *iterator_at(i)) ==
 3155|     26|               iterator_at(i) &&
 3156|     26|           "constructed value does not match the lookup key");
 3157|     26|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSG_EEENSO_IJOSA_EEEEEEvPNS1_13map_slot_typeIS8_SA_EEDpOT_:
 2851|     26|  inline void construct(slot_type* slot, Args&&... args) {
 2852|     26|    PolicyTraits::construct(&alloc_ref(), slot, std::forward<Args>(args)...);
 2853|     26|  }
_ZNK4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE4sizeEv:
 2287|      2|  size_t size() const { return common().size(); }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEE5clearEv:
 2291|      2|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2292|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2293|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2294|       |    // For clear() it is more important to reuse the allocated array when the
 2295|       |    // container is small because allocation takes comparatively long time
 2296|       |    // compared to destruction of the elements of the container. So we pick the
 2297|       |    // largest bucket_count() threshold for which iteration is still fast and
 2298|       |    // past that we simply deallocate the array.
 2299|      2|    const size_t cap = capacity();
 2300|      2|    if (cap == 0) {
  ------------------
  |  Branch (2300:9): [True: 0, False: 2]
  ------------------
 2301|       |      // Already guaranteed to be empty; so nothing to do.
 2302|      2|    } else {
 2303|      2|      destroy_slots();
 2304|      2|      ClearBackingArray(common(), GetPolicyFunctions(), /*reuse=*/cap < 128);
 2305|      2|    }
 2306|      2|    common().set_reserved_growth(0);
 2307|      2|    common().set_reservation_size(0);
 2308|      2|  }
_ZN4absl12lts_2024011618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEPNS0_15CommandLineFlagEEENS1_10StringHashENS1_8StringEqENS4_9allocatorINS4_4pairIKS8_SA_EEEEEC2Ev:
 2088|      2|      std::is_nothrow_default_constructible<allocator_type>::value) {}

_ZNK4absl12lts_2024011615CommandLineFlag8IsOfTypeIbEEbv:
   74|      2|  inline bool IsOfType() const {
   75|      2|    return TypeId() == base_internal::FastTypeId<T>();
   76|      2|  }

_ZN25AbslFlagDefaultGenForfuzz3GenEPv:
  252|      4|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      4|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      4|    }                                                                         \
_ZN29AbslFlagDefaultGenForfuzz_for3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN36AbslFlagDefaultGenForcorpus_database3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN41AbslFlagDefaultGenFortime_limit_per_input3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN4absl12lts_202401167GetFlagINS0_8DurationEEET_RKNS0_14flags_internal4FlagIS3_EE:
   95|      4|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      4|}
_ZN4absl12lts_202401167GetFlagImEET_RKNS0_14flags_internal4FlagIS2_EE:
   95|      4|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      4|}
_ZN4absl12lts_202401167GetFlagIbEET_RKNS0_14flags_internal4FlagIS2_EE:
   95|      8|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      8|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      8|}
_ZN4absl12lts_202401167GetFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEET_RKNS0_14flags_internal4FlagIS9_EE:
   95|      4|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|      4|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|      4|}
_ZN29AbslFlagDefaultGenForflagfile3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN28AbslFlagDefaultGenForfromenv3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN31AbslFlagDefaultGenFortryfromenv3GenEPv:
  252|      2|    static void Gen(void* absl_flag_default_loc) {                            \
  253|      2|      new (absl_flag_default_loc) Type(AbslFlagDefaultGenFor##name{}.value);  \
  254|      2|    }                                                                         \
_ZN4absl12lts_202401167GetFlagINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEET_RKNS0_14flags_internal4FlagISC_EE:
   95|     10|ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
   96|     10|  return flags_internal::FlagImplPeer::InvokeGet<T>(flag);
   97|     10|}

_ZN4absl12lts_2024011614flags_internal15DynValueDeleterC2EPFPvNS1_6FlagOpEPKvS3_S3_E:
  135|      2|DynValueDeleter::DynValueDeleter(FlagOpFn op_arg) : op(op_arg) {}
_ZNK4absl12lts_2024011614flags_internal15DynValueDeleterclEPv:
  137|      2|void DynValueDeleter::operator()(void* ptr) const {
  138|      2|  if (op == nullptr) return;
  ------------------
  |  Branch (138:7): [True: 0, False: 2]
  ------------------
  139|       |
  140|      2|  Delete(op, ptr);
  141|      2|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl4InitEv:
  143|     24|void FlagImpl::Init() {
  144|     24|  new (&data_guard_) absl::Mutex;
  145|       |
  146|     24|  auto def_kind = static_cast<FlagDefaultKind>(def_kind_);
  147|       |
  148|     24|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (148:11): [True: 24, False: 0]
  ------------------
  149|      6|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (149:5): [True: 6, False: 18]
  ------------------
  150|     10|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (150:5): [True: 4, False: 20]
  ------------------
  151|     10|      alignas(int64_t) std::array<char, sizeof(int64_t)> buf{};
  152|     10|      if (def_kind == FlagDefaultKind::kGenFunc) {
  ------------------
  |  Branch (152:11): [True: 0, False: 10]
  ------------------
  153|      0|        (*default_value_.gen_func)(buf.data());
  154|     10|      } else {
  155|     10|        assert(def_kind != FlagDefaultKind::kDynamicValue);
  156|     10|        std::memcpy(buf.data(), &default_value_, Sizeof(op_));
  157|     10|      }
  158|     10|      if (ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit) {
  ------------------
  |  Branch (158:11): [True: 6, False: 4]
  ------------------
  159|       |        // We presume here the memory layout of FlagValueAndInitBit struct.
  160|      6|        uint8_t initialized = 1;
  161|      6|        std::memcpy(buf.data() + Sizeof(op_), &initialized,
  162|      6|                    sizeof(initialized));
  163|      6|      }
  164|       |      // Type can contain valid uninitialized bits, e.g. padding.
  165|     10|      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buf.data(), buf.size());
  166|     10|      OneWordValue().store(absl::bit_cast<int64_t>(buf),
  167|     10|                           std::memory_order_release);
  168|     10|      break;
  169|      6|    }
  170|      4|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (170:5): [True: 4, False: 20]
  ------------------
  171|       |      // For this storage kind the default_value_ always points to gen_func
  172|       |      // during initialization.
  173|      4|      assert(def_kind == FlagDefaultKind::kGenFunc);
  174|      4|      (*default_value_.gen_func)(AtomicBufferValue());
  175|      4|      break;
  176|      6|    }
  177|     10|    case FlagValueStorageKind::kAlignedBuffer:
  ------------------
  |  Branch (177:5): [True: 10, False: 14]
  ------------------
  178|       |      // For this storage kind the default_value_ always points to gen_func
  179|       |      // during initialization.
  180|     10|      assert(def_kind == FlagDefaultKind::kGenFunc);
  181|     10|      (*default_value_.gen_func)(AlignedBufferValue());
  182|     10|      break;
  183|     24|  }
  184|     24|  seq_lock_.MarkInitialized();
  185|     24|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl9DataGuardEv:
  187|     44|absl::Mutex* FlagImpl::DataGuard() const {
  188|     44|  absl::call_once(const_cast<FlagImpl*>(this)->init_control_, &FlagImpl::Init,
  189|     44|                  const_cast<FlagImpl*>(this));
  190|       |
  191|       |  // data_guard_ is initialized inside Init.
  192|     44|  return reinterpret_cast<absl::Mutex*>(&data_guard_);
  193|     44|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl13MakeInitValueEv:
  220|      2|std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
  221|      2|  void* res = nullptr;
  222|      2|  switch (DefaultKind()) {
  223|      0|    case FlagDefaultKind::kDynamicValue:
  ------------------
  |  Branch (223:5): [True: 0, False: 2]
  ------------------
  224|      0|      res = flags_internal::Clone(op_, default_value_.dynamic_value);
  225|      0|      break;
  226|      2|    case FlagDefaultKind::kGenFunc:
  ------------------
  |  Branch (226:5): [True: 2, False: 0]
  ------------------
  227|      2|      res = flags_internal::Alloc(op_);
  228|      2|      (*default_value_.gen_func)(res);
  229|      2|      break;
  230|      0|    default:
  ------------------
  |  Branch (230:5): [True: 0, False: 2]
  ------------------
  231|      0|      res = flags_internal::Clone(op_, &default_value_);
  232|      0|      break;
  233|      2|  }
  234|      2|  return {res, DynValueDeleter{op_}};
  235|      2|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl10StoreValueEPKv:
  237|      2|void FlagImpl::StoreValue(const void* src) {
  238|      2|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (238:11): [True: 2, False: 0]
  ------------------
  239|      0|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (239:5): [True: 0, False: 2]
  ------------------
  240|      0|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (240:5): [True: 0, False: 2]
  ------------------
  241|       |      // Load the current value to avoid setting 'init' bit manually.
  242|      0|      int64_t one_word_val = OneWordValue().load(std::memory_order_acquire);
  243|      0|      std::memcpy(&one_word_val, src, Sizeof(op_));
  244|      0|      OneWordValue().store(one_word_val, std::memory_order_release);
  245|      0|      seq_lock_.IncrementModificationCount();
  246|      0|      break;
  247|      0|    }
  248|      0|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (248:5): [True: 0, False: 2]
  ------------------
  249|      0|      seq_lock_.Write(AtomicBufferValue(), src, Sizeof(op_));
  250|      0|      break;
  251|      0|    }
  252|      2|    case FlagValueStorageKind::kAlignedBuffer:
  ------------------
  |  Branch (252:5): [True: 2, False: 0]
  ------------------
  253|      2|      Copy(op_, src, AlignedBufferValue());
  254|      2|      seq_lock_.IncrementModificationCount();
  255|      2|      break;
  256|      2|  }
  257|      2|  modified_ = true;
  258|      2|  InvokeCallback();
  259|      2|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4NameEv:
  261|    196|absl::string_view FlagImpl::Name() const { return name_; }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl8FilenameEv:
  263|     26|std::string FlagImpl::Filename() const {
  264|     26|  return flags_internal::GetUsageConfig().normalize_filename(filename_);
  265|     26|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl6TypeIdEv:
  272|      2|FlagFastTypeId FlagImpl::TypeId() const {
  273|      2|  return flags_internal::FastTypeId(op_);
  274|      2|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl11SetCallbackEPFvvE:
  317|      8|void FlagImpl::SetCallback(const FlagCallbackFunc mutation_callback) {
  318|      8|  absl::MutexLock l(DataGuard());
  319|       |
  320|      8|  if (callback_ == nullptr) {
  ------------------
  |  Branch (320:7): [True: 8, False: 0]
  ------------------
  321|      8|    callback_ = new FlagCallback;
  322|      8|  }
  323|      8|  callback_->func = mutation_callback;
  324|       |
  325|      8|  InvokeCallback();
  326|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl14InvokeCallbackEv:
  328|     10|void FlagImpl::InvokeCallback() const {
  329|     10|  if (!callback_) return;
  ------------------
  |  Branch (329:7): [True: 2, False: 8]
  ------------------
  330|       |
  331|       |  // Make a copy of the C-style function pointer that we are about to invoke
  332|       |  // before we release the lock guarding it.
  333|      8|  FlagCallbackFunc cb = callback_->func;
  334|       |
  335|       |  // If the flag has a mutation callback this function invokes it. While the
  336|       |  // callback is being invoked the primary flag's mutex is unlocked and it is
  337|       |  // re-locked back after call to callback is completed. Callback invocation is
  338|       |  // guarded by flag's secondary mutex instead which prevents concurrent
  339|       |  // callback invocation. Note that it is possible for other thread to grab the
  340|       |  // primary lock and update flag's value at any time during the callback
  341|       |  // invocation. This is by design. Callback can get a value of the flag if
  342|       |  // necessary, but it might be different from the value initiated the callback
  343|       |  // and it also can be different by the time the callback invocation is
  344|       |  // completed. Requires that *primary_lock be held in exclusive mode; it may be
  345|       |  // released and reacquired by the implementation.
  346|      8|  MutexRelock relock(*DataGuard());
  347|      8|  absl::MutexLock lock(&callback_->guard);
  348|      8|  cb();
  349|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl18AlignedBufferValueEv:
  414|     26|void* FlagImpl::AlignedBufferValue() const {
  415|       |  assert(ValueStorageKind() == FlagValueStorageKind::kAlignedBuffer);
  416|     26|  return OffsetValue<void>();
  417|     26|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl17AtomicBufferValueEv:
  419|      8|std::atomic<uint64_t>* FlagImpl::AtomicBufferValue() const {
  420|       |  assert(ValueStorageKind() == FlagValueStorageKind::kSequenceLocked);
  421|      8|  return OffsetValue<std::atomic<uint64_t>>();
  422|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl12OneWordValueEv:
  424|     18|std::atomic<int64_t>& FlagImpl::OneWordValue() const {
  425|       |  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
  426|     18|         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  427|     18|  return OffsetValue<FlagOneWordValue>()->value;
  428|     18|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl8TryParseENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE:
  435|      2|    absl::string_view value, std::string& err) const {
  436|      2|  std::unique_ptr<void, DynValueDeleter> tentative_value = MakeInitValue();
  437|       |
  438|      2|  std::string parse_err;
  439|      2|  if (!flags_internal::Parse(op_, value, tentative_value.get(), &parse_err)) {
  ------------------
  |  Branch (439:7): [True: 0, False: 2]
  ------------------
  440|      0|    absl::string_view err_sep = parse_err.empty() ? "" : "; ";
  ------------------
  |  Branch (440:33): [True: 0, False: 0]
  ------------------
  441|      0|    err = absl::StrCat("Illegal value '", value, "' specified for flag '",
  442|      0|                       Name(), "'", err_sep, parse_err);
  443|      0|    return nullptr;
  444|      0|  }
  445|       |
  446|      2|  return tentative_value;
  447|      2|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadEPv:
  449|     18|void FlagImpl::Read(void* dst) const {
  450|     18|  auto* guard = DataGuard();  // Make sure flag initialized
  451|     18|  switch (ValueStorageKind()) {
  ------------------
  |  Branch (451:11): [True: 18, False: 0]
  ------------------
  452|      0|    case FlagValueStorageKind::kValueAndInitBit:
  ------------------
  |  Branch (452:5): [True: 0, False: 18]
  ------------------
  453|      0|    case FlagValueStorageKind::kOneWordAtomic: {
  ------------------
  |  Branch (453:5): [True: 0, False: 18]
  ------------------
  454|      0|      const int64_t one_word_val =
  455|      0|          OneWordValue().load(std::memory_order_acquire);
  456|      0|      std::memcpy(dst, &one_word_val, Sizeof(op_));
  457|      0|      break;
  458|      0|    }
  459|      4|    case FlagValueStorageKind::kSequenceLocked: {
  ------------------
  |  Branch (459:5): [True: 4, False: 14]
  ------------------
  460|      4|      ReadSequenceLockedData(dst);
  461|      4|      break;
  462|      0|    }
  463|     14|    case FlagValueStorageKind::kAlignedBuffer: {
  ------------------
  |  Branch (463:5): [True: 14, False: 4]
  ------------------
  464|     14|      absl::MutexLock l(guard);
  465|     14|      flags_internal::CopyConstruct(op_, AlignedBufferValue(), dst);
  466|     14|      break;
  467|      0|    }
  468|     18|  }
  469|     18|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11ReadOneWordEv:
  471|      4|int64_t FlagImpl::ReadOneWord() const {
  472|       |  assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic ||
  473|      4|         ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  474|      4|  auto* guard = DataGuard();  // Make sure flag initialized
  475|      4|  (void)guard;
  476|      4|  return OneWordValue().load(std::memory_order_acquire);
  477|      4|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11ReadOneBoolEv:
  479|      4|bool FlagImpl::ReadOneBool() const {
  480|       |  assert(ValueStorageKind() == FlagValueStorageKind::kValueAndInitBit);
  481|      4|  auto* guard = DataGuard();  // Make sure flag initialized
  482|      4|  (void)guard;
  483|      4|  return absl::bit_cast<FlagValueAndInitBit<bool>>(
  484|      4|             OneWordValue().load(std::memory_order_acquire))
  485|      4|      .value;
  486|      4|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl22ReadSequenceLockedDataEPv:
  488|      4|void FlagImpl::ReadSequenceLockedData(void* dst) const {
  489|      4|  size_t size = Sizeof(op_);
  490|       |  // Attempt to read using the sequence lock.
  491|      4|  if (ABSL_PREDICT_TRUE(seq_lock_.TryRead(dst, AtomicBufferValue(), size))) {
  ------------------
  |  |  179|      4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:30): [True: 4, False: 0]
  |  |  |  Branch (179:48): [Folded, False: 4]
  |  |  |  Branch (179:57): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  492|      4|    return;
  493|      4|  }
  494|       |  // We failed due to contention. Acquire the lock to prevent contention
  495|       |  // and try again.
  496|      0|  absl::ReaderMutexLock l(DataGuard());
  497|      0|  bool success = seq_lock_.TryRead(dst, AtomicBufferValue(), size);
  498|       |  assert(success);
  499|      0|  static_cast<void>(success);
  500|      0|}
_ZN4absl12lts_2024011614flags_internal8FlagImpl9ParseFromENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEE:
  528|      2|                         ValueSource source, std::string& err) {
  529|      2|  absl::MutexLock l(DataGuard());
  530|       |
  531|      2|  switch (set_mode) {
  ------------------
  |  Branch (531:11): [True: 2, False: 0]
  ------------------
  532|      2|    case SET_FLAGS_VALUE: {
  ------------------
  |  Branch (532:5): [True: 2, False: 0]
  ------------------
  533|       |      // set or modify the flag's value
  534|      2|      auto tentative_value = TryParse(value, err);
  535|      2|      if (!tentative_value) return false;
  ------------------
  |  Branch (535:11): [True: 0, False: 2]
  ------------------
  536|       |
  537|      2|      StoreValue(tentative_value.get());
  538|       |
  539|      2|      if (source == kCommandLine) {
  ------------------
  |  Branch (539:11): [True: 2, False: 0]
  ------------------
  540|      2|        on_command_line_ = true;
  541|      2|      }
  542|      2|      break;
  543|      2|    }
  544|      0|    case SET_FLAG_IF_DEFAULT: {
  ------------------
  |  Branch (544:5): [True: 0, False: 2]
  ------------------
  545|       |      // set the flag's value, but only if it hasn't been set by someone else
  546|      0|      if (modified_) {
  ------------------
  |  Branch (546:11): [True: 0, False: 0]
  ------------------
  547|       |        // TODO(rogeeff): review and fix this semantic. Currently we do not fail
  548|       |        // in this case if flag is modified. This is misleading since the flag's
  549|       |        // value is not updated even though we return true.
  550|       |        // *err = absl::StrCat(Name(), " is already set to ",
  551|       |        //                     CurrentValue(), "\n");
  552|       |        // return false;
  553|      0|        return true;
  554|      0|      }
  555|      0|      auto tentative_value = TryParse(value, err);
  556|      0|      if (!tentative_value) return false;
  ------------------
  |  Branch (556:11): [True: 0, False: 0]
  ------------------
  557|       |
  558|      0|      StoreValue(tentative_value.get());
  559|      0|      break;
  560|      0|    }
  561|      0|    case SET_FLAGS_DEFAULT: {
  ------------------
  |  Branch (561:5): [True: 0, False: 2]
  ------------------
  562|      0|      auto tentative_value = TryParse(value, err);
  563|      0|      if (!tentative_value) return false;
  ------------------
  |  Branch (563:11): [True: 0, False: 0]
  ------------------
  564|       |
  565|      0|      if (DefaultKind() == FlagDefaultKind::kDynamicValue) {
  ------------------
  |  Branch (565:11): [True: 0, False: 0]
  ------------------
  566|      0|        void* old_value = default_value_.dynamic_value;
  567|      0|        default_value_.dynamic_value = tentative_value.release();
  568|      0|        tentative_value.reset(old_value);
  569|      0|      } else {
  570|      0|        default_value_.dynamic_value = tentative_value.release();
  571|      0|        def_kind_ = static_cast<uint8_t>(FlagDefaultKind::kDynamicValue);
  572|      0|      }
  573|       |
  574|      0|      if (!modified_) {
  ------------------
  |  Branch (574:11): [True: 0, False: 0]
  ------------------
  575|       |        // Need to set both default value *and* current, in this case.
  576|      0|        StoreValue(default_value_.dynamic_value);
  577|      0|        modified_ = false;
  578|      0|      }
  579|      0|      break;
  580|      0|    }
  581|      2|  }
  582|       |
  583|      2|  return true;
  584|      2|}
flag.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_111MutexRelockC2ERNS0_5MutexE:
   71|      8|  explicit MutexRelock(absl::Mutex& mu) : mu_(mu) { mu_.Unlock(); }
flag.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_111MutexRelockD2Ev:
   72|      8|  ~MutexRelock() { mu_.Lock(); }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueIvEEPT_v:
  406|     26|StorageT* FlagImpl::OffsetValue() const {
  407|     26|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  408|       |  // The offset is deduced via Flag value type specific op_.
  409|     26|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  410|       |
  411|     26|  return reinterpret_cast<StorageT*>(p + offset);
  412|     26|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueINSt3__16atomicImEEEEPT_v:
  406|      8|StorageT* FlagImpl::OffsetValue() const {
  407|      8|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  408|       |  // The offset is deduced via Flag value type specific op_.
  409|      8|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  410|       |
  411|      8|  return reinterpret_cast<StorageT*>(p + offset);
  412|      8|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11OffsetValueINS1_16FlagOneWordValueEEEPT_v:
  406|     18|StorageT* FlagImpl::OffsetValue() const {
  407|     18|  char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
  408|       |  // The offset is deduced via Flag value type specific op_.
  409|     18|  ptrdiff_t offset = flags_internal::ValueOffset(op_);
  410|       |
  411|     18|  return reinterpret_cast<StorageT*>(p + offset);
  412|     18|}

_ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEET_SA_:
  277|      6|constexpr T InitDefaultValue(T t) {
  278|      6|  return t;
  279|      6|}
_ZN4absl12lts_2024011614flags_internal16InitDefaultValueINS0_8DurationEEET_S4_:
  277|      4|constexpr T InitDefaultValue(T t) {
  278|      4|  return t;
  279|      4|}
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINS0_8DurationENS1_4FlagIS4_EEEET_RKT0_:
  697|      4|  static T InvokeGet(const FlagType& flag) {
  698|      4|    return flag.Get();
  699|      4|  }
_ZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEv:
  657|      4|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      4|    union U {
  660|      4|      T value;
  661|      4|      U() {}
  662|      4|      ~U() { value.~T(); }
  663|      4|    };
  664|      4|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      4|    return std::move(u.value);
  674|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEvEN1UC2Ev:
  661|      4|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueINS0_8DurationELNS1_20FlagValueStorageKindE2EE3GetERKNS1_12SequenceLockERS3_:
  384|      4|  bool Get(const SequenceLock& lock, T& dst) const {
  385|      4|    return lock.TryRead(&dst, value_words, sizeof(T));
  386|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINS0_8DurationEE3GetEvEN1UD2Ev:
  662|      4|      ~U() { value.~T(); }
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetImNS1_4FlagImEEEET_RKT0_:
  697|      4|  static T InvokeGet(const FlagType& flag) {
  698|      4|    return flag.Get();
  699|      4|  }
_ZNK4absl12lts_2024011614flags_internal4FlagImE3GetEv:
  657|      4|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      4|    union U {
  660|      4|      T value;
  661|      4|      U() {}
  662|      4|      ~U() { value.~T(); }
  663|      4|    };
  664|      4|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      4|    return std::move(u.value);
  674|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagImE3GetEvEN1UC2Ev:
  661|      4|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueImLNS1_20FlagValueStorageKindE1EE3GetERKNS1_12SequenceLockERm:
  372|      4|  bool Get(const SequenceLock&, T& dst) const {
  373|      4|    int64_t one_word_val = value.load(std::memory_order_acquire);
  374|      4|    if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  375|      4|      return false;
  376|      4|    }
  377|      0|    std::memcpy(&dst, static_cast<const void*>(&one_word_val), sizeof(T));
  378|      0|    return true;
  379|      4|  }
_ZN4absl12lts_2024011614flags_internal22UninitializedFlagValueEv:
  301|      4|constexpr int64_t UninitializedFlagValue() {
  302|      4|  return static_cast<int64_t>(0xababababababababll);
  303|      4|}
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadImTnNSt3__19enable_ifIXeqclsr14flags_internalE11StorageKindIT_EELNS1_20FlagValueStorageKindE1EEiE4typeELi0EEEvPS6_:
  457|      4|  void Read(T* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
  458|      4|    int64_t v = ReadOneWord();
  459|      4|    std::memcpy(value, static_cast<const void*>(&v), sizeof(T));
  460|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagImE3GetEvEN1UD2Ev:
  662|      4|      ~U() { value.~T(); }
_ZN4absl12lts_2024011614flags_internal7FlagOpsIbEEPvNS1_6FlagOpEPKvS3_S3_:
  713|     22|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     22|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 22, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 22]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 22]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 22]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 0, False: 22]
  ------------------
  730|      0|      new (v2) T(*static_cast<const T*>(v1));
  731|      0|      return nullptr;
  732|     12|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 12, False: 10]
  ------------------
  733|     12|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 22]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 22]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 22]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 22]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|     10|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 10, False: 12]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|     10|      size_t round_to = alignof(FlagValue<T>);
  757|     10|      size_t offset =
  758|     10|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|     10|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     22|  }
  762|      0|  return nullptr;
  763|     22|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EEC2ERNS1_4FlagIbEEPKc:
  773|      6|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      6|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 6, Folded]
  ------------------
  775|      6|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      6|  }
_ZNO4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EE8OnUpdateEPFvvE:
  778|      2|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  779|      2|    flag_.impl_.SetCallback(cb);
  780|      2|    return *this;
  781|      2|  }
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetIbNS1_4FlagIbEEEET_RKT0_:
  697|      8|  static T InvokeGet(const FlagType& flag) {
  698|      8|    return flag.Get();
  699|      8|  }
_ZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEv:
  657|      8|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      8|    union U {
  660|      8|      T value;
  661|      8|      U() {}
  662|      8|      ~U() { value.~T(); }
  663|      8|    };
  664|      8|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      8|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 4]
  |  |  |  Branch (178:49): [Folded, False: 8]
  |  |  |  Branch (178:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      8|    return std::move(u.value);
  674|      8|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEvEN1UC2Ev:
  661|      8|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueIbLNS1_20FlagValueStorageKindE0EE3GetERKNS1_12SequenceLockERb:
  359|      8|  bool Get(const SequenceLock&, T& dst) const {
  360|      8|    int64_t storage = value.load(std::memory_order_acquire);
  361|      8|    if (ABSL_PREDICT_FALSE(storage == 0)) {
  ------------------
  |  |  178|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 4]
  |  |  |  Branch (178:49): [Folded, False: 8]
  |  |  |  Branch (178:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
  362|      4|      return false;
  363|      4|    }
  364|      4|    dst = absl::bit_cast<FlagValueAndInitBit<T>>(storage).value;
  365|      4|    return true;
  366|      8|  }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl4ReadEPb:
  450|      4|  void Read(bool* value) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
  451|      4|    *value = ReadOneBool();
  452|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagIbE3GetEvEN1UD2Ev:
  662|      8|      ~U() { value.~T(); }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarIbLb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      6|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEPvNS1_6FlagOpEPKvSA_SA_:
  713|     24|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     24|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 24, False: 0]
  ------------------
  715|      2|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 2, False: 22]
  ------------------
  716|      2|      std::allocator<T> alloc;
  717|      2|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      2|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 2, False: 22]
  ------------------
  720|      2|      T* p = static_cast<T*>(v2);
  721|      2|      p->~T();
  722|      2|      std::allocator<T> alloc;
  723|      2|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      2|      return nullptr;
  725|      0|    }
  726|      2|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 2, False: 22]
  ------------------
  727|      2|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      2|      return nullptr;
  729|      4|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 4, False: 20]
  ------------------
  730|      4|      new (v2) T(*static_cast<const T*>(v1));
  731|      4|      return nullptr;
  732|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 0, False: 24]
  ------------------
  733|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      2|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 2, False: 22]
  ------------------
  735|      2|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 24]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      2|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 2, False: 22]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      2|      T temp(*static_cast<T*>(v2));
  742|      2|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 2]
  ------------------
  743|      2|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      2|      *static_cast<T*>(v2) = std::move(temp);
  747|      2|      return v2;
  748|      2|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 24]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|     10|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 10, False: 14]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|     10|      size_t round_to = alignof(FlagValue<T>);
  757|     10|      size_t offset =
  758|     10|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|     10|      return reinterpret_cast<void*>(offset);
  760|      2|    }
  761|     24|  }
  762|      0|  return nullptr;
  763|     24|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEC2ERNS1_4FlagIS9_EEPKc:
  773|      4|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      4|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 4, Folded]
  ------------------
  775|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      4|  }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      4|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal7FlagOpsINS0_8DurationEEEPvNS1_6FlagOpEPKvS4_S4_:
  713|     12|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     12|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 12, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 12]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 12]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 12]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 0, False: 12]
  ------------------
  730|      0|      new (v2) T(*static_cast<const T*>(v1));
  731|      0|      return nullptr;
  732|      4|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 4, False: 8]
  ------------------
  733|      4|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 12]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 12]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 12]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 12]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|      8|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 8, False: 4]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|      8|      size_t round_to = alignof(FlagValue<T>);
  757|      8|      size_t offset =
  758|      8|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|      8|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     12|  }
  762|      0|  return nullptr;
  763|     12|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarINS0_8DurationELb1EEC2ERNS1_4FlagIS3_EEPKc:
  773|      4|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      4|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 4, Folded]
  ------------------
  775|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      4|  }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINS0_8DurationELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      4|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal7FlagOpsImEEPvNS1_6FlagOpEPKvS3_S3_:
  713|     12|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     12|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 12, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 12]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 12]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 12]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|      0|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 0, False: 12]
  ------------------
  730|      0|      new (v2) T(*static_cast<const T*>(v1));
  731|      0|      return nullptr;
  732|      4|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 4, False: 8]
  ------------------
  733|      4|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 12]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 12]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 12]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 12]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|      8|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 8, False: 4]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|      8|      size_t round_to = alignof(FlagValue<T>);
  757|      8|      size_t offset =
  758|      8|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|      8|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     12|  }
  762|      0|  return nullptr;
  763|     12|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarImLb1EEC2ERNS1_4FlagImEEPKc:
  773|      4|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      4|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 4, Folded]
  ------------------
  775|      4|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      4|  }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarImLb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      4|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_4FlagISA_EEEET_RKT0_:
  697|      4|  static T InvokeGet(const FlagType& flag) {
  698|      4|    return flag.Get();
  699|      4|  }
_ZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
  657|      4|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|      4|    union U {
  660|      4|      T value;
  661|      4|      U() {}
  662|      4|      ~U() { value.~T(); }
  663|      4|    };
  664|      4|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|      4|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|      4|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 4, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 4]
  |  |  |  Branch (178:58): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  671|      4|      impl_.Read(&u.value);
  672|      4|    }
  673|      4|    return std::move(u.value);
  674|      4|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UC2Ev:
  661|      4|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERS9_:
  397|      4|  bool Get(const SequenceLock&, T&) const { return false; }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEvEN1UD2Ev:
  662|      4|      ~U() { value.~T(); }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl16ValueStorageKindEv:
  537|     54|  FlagValueStorageKind ValueStorageKind() const {
  538|     54|    return static_cast<FlagValueStorageKind>(value_storage_kind_);
  539|     54|  }
_ZNK4absl12lts_2024011614flags_internal8FlagImpl11DefaultKindEv:
  541|      2|      ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard()) {
  542|      2|    return static_cast<FlagDefaultKind>(def_kind_);
  543|      2|  }
_ZN4absl12lts_2024011614flags_internal5AllocEPFPvNS1_6FlagOpEPKvS2_S2_E:
   97|      2|inline void* Alloc(FlagOpFn op) {
   98|      2|  return op(FlagOp::kAlloc, nullptr, nullptr, nullptr);
   99|      2|}
_ZN4absl12lts_2024011614flags_internal6DeleteEPFPvNS1_6FlagOpEPKvS2_S2_ES2_:
  101|      2|inline void Delete(FlagOpFn op, void* obj) {
  102|      2|  op(FlagOp::kDelete, nullptr, obj, nullptr);
  103|      2|}
_ZN4absl12lts_2024011614flags_internal4CopyEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_:
  105|      2|inline void Copy(FlagOpFn op, const void* src, void* dst) {
  106|      2|  op(FlagOp::kCopy, src, dst, nullptr);
  107|      2|}
_ZN4absl12lts_2024011614flags_internal13CopyConstructEPFPvNS1_6FlagOpEPKvS2_S2_ES5_S2_:
  110|     14|inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
  111|     14|  op(FlagOp::kCopyConstruct, src, dst, nullptr);
  112|     14|}
_ZN4absl12lts_2024011614flags_internal5ParseEPFPvNS1_6FlagOpEPKvS2_S2_ENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEES2_PNS8_12basic_stringIcSB_NS8_9allocatorIcEEEE:
  121|      2|                  std::string* error) {
  122|      2|  return op(FlagOp::kParse, &text, dst, error) != nullptr;
  123|      2|}
_ZN4absl12lts_2024011614flags_internal6SizeofEPFPvNS1_6FlagOpEPKvS2_S2_E:
  131|     20|inline size_t Sizeof(FlagOpFn op) {
  132|       |  // This sequence of casts reverses the sequence from
  133|       |  // `flags_internal::FlagOps()`
  134|     20|  return static_cast<size_t>(reinterpret_cast<intptr_t>(
  135|     20|      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
  136|     20|}
_ZN4absl12lts_2024011614flags_internal10FastTypeIdEPFPvNS1_6FlagOpEPKvS2_S2_E:
  138|      2|inline FlagFastTypeId FastTypeId(FlagOpFn op) {
  139|      2|  return reinterpret_cast<FlagFastTypeId>(
  140|      2|      op(FlagOp::kFastTypeId, nullptr, nullptr, nullptr));
  141|      2|}
_ZN4absl12lts_2024011614flags_internal11ValueOffsetEPFPvNS1_6FlagOpEPKvS2_S2_E:
  151|     52|inline ptrdiff_t ValueOffset(FlagOpFn op) {
  152|       |  // This sequence of casts reverses the sequence from
  153|       |  // `flags_internal::FlagOps()`
  154|     52|  return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
  155|     52|      op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
  156|     52|}
_ZN4absl12lts_2024011614flags_internal16InitDefaultValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEET_NS1_11EmptyBracesE:
  282|      6|constexpr T InitDefaultValue(EmptyBraces) {
  283|      6|  return T{};
  284|      6|}
_ZN4absl12lts_2024011614flags_internal7FlagOpsINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEEPvNS1_6FlagOpEPKvSD_SD_:
  713|     26|void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
  714|     26|  switch (op) {
  ------------------
  |  Branch (714:11): [True: 26, False: 0]
  ------------------
  715|      0|    case FlagOp::kAlloc: {
  ------------------
  |  Branch (715:5): [True: 0, False: 26]
  ------------------
  716|      0|      std::allocator<T> alloc;
  717|      0|      return std::allocator_traits<std::allocator<T>>::allocate(alloc, 1);
  718|      0|    }
  719|      0|    case FlagOp::kDelete: {
  ------------------
  |  Branch (719:5): [True: 0, False: 26]
  ------------------
  720|      0|      T* p = static_cast<T*>(v2);
  721|      0|      p->~T();
  722|      0|      std::allocator<T> alloc;
  723|      0|      std::allocator_traits<std::allocator<T>>::deallocate(alloc, p, 1);
  724|      0|      return nullptr;
  725|      0|    }
  726|      0|    case FlagOp::kCopy:
  ------------------
  |  Branch (726:5): [True: 0, False: 26]
  ------------------
  727|      0|      *static_cast<T*>(v2) = *static_cast<const T*>(v1);
  728|      0|      return nullptr;
  729|     10|    case FlagOp::kCopyConstruct:
  ------------------
  |  Branch (729:5): [True: 10, False: 16]
  ------------------
  730|     10|      new (v2) T(*static_cast<const T*>(v1));
  731|     10|      return nullptr;
  732|      0|    case FlagOp::kSizeof:
  ------------------
  |  Branch (732:5): [True: 0, False: 26]
  ------------------
  733|      0|      return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
  734|      0|    case FlagOp::kFastTypeId:
  ------------------
  |  Branch (734:5): [True: 0, False: 26]
  ------------------
  735|      0|      return const_cast<void*>(base_internal::FastTypeId<T>());
  736|      0|    case FlagOp::kRuntimeTypeId:
  ------------------
  |  Branch (736:5): [True: 0, False: 26]
  ------------------
  737|      0|      return const_cast<std::type_info*>(GenRuntimeTypeId<T>());
  738|      0|    case FlagOp::kParse: {
  ------------------
  |  Branch (738:5): [True: 0, False: 26]
  ------------------
  739|       |      // Initialize the temporary instance of type T based on current value in
  740|       |      // destination (which is going to be flag's default value).
  741|      0|      T temp(*static_cast<T*>(v2));
  742|      0|      if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
  ------------------
  |  Branch (742:11): [True: 0, False: 0]
  ------------------
  743|      0|                              static_cast<std::string*>(v3))) {
  744|      0|        return nullptr;
  745|      0|      }
  746|      0|      *static_cast<T*>(v2) = std::move(temp);
  747|      0|      return v2;
  748|      0|    }
  749|      0|    case FlagOp::kUnparse:
  ------------------
  |  Branch (749:5): [True: 0, False: 26]
  ------------------
  750|      0|      *static_cast<std::string*>(v2) =
  751|      0|          absl::UnparseFlag<T>(*static_cast<const T*>(v1));
  752|      0|      return nullptr;
  753|     16|    case FlagOp::kValueOffset: {
  ------------------
  |  Branch (753:5): [True: 16, False: 10]
  ------------------
  754|       |      // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
  755|       |      // offset of the data.
  756|     16|      size_t round_to = alignof(FlagValue<T>);
  757|     16|      size_t offset =
  758|     16|          (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
  759|     16|      return reinterpret_cast<void*>(offset);
  760|      0|    }
  761|     26|  }
  762|      0|  return nullptr;
  763|     26|}
_ZN4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEC2ERNS1_4FlagISC_EEPKc:
  773|      8|  explicit FlagRegistrar(Flag<T>& flag, const char* filename) : flag_(flag) {
  774|      8|    if (do_register)
  ------------------
  |  Branch (774:9): [True: 8, Folded]
  ------------------
  775|      8|      flags_internal::RegisterCommandLineFlag(flag_.impl_, filename);
  776|      8|  }
_ZNO4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EE8OnUpdateEPFvvE:
  778|      6|  FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
  779|      6|    flag_.impl_.SetCallback(cb);
  780|      6|    return *this;
  781|      6|  }
_ZN4absl12lts_2024011614flags_internal12FlagImplPeer9InvokeGetINSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEENS1_4FlagISD_EEEET_RKT0_:
  697|     10|  static T InvokeGet(const FlagType& flag) {
  698|     10|    return flag.Get();
  699|     10|  }
_ZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEv:
  657|     10|  T Get() const {
  658|       |    // See implementation notes in CommandLineFlag::Get().
  659|     10|    union U {
  660|     10|      T value;
  661|     10|      U() {}
  662|     10|      ~U() { value.~T(); }
  663|     10|    };
  664|     10|    U u;
  665|       |
  666|       |#if !defined(NDEBUG)
  667|       |    impl_.AssertValidType(base_internal::FastTypeId<T>(), &GenRuntimeTypeId<T>);
  668|       |#endif
  669|       |
  670|     10|    if (ABSL_PREDICT_FALSE(!value_.Get(impl_.seq_lock_, u.value))) {
  ------------------
  |  |  178|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 10, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 10]
  |  |  |  Branch (178:58): [True: 10, False: 0]
  |  |  ------------------
  ------------------
  671|     10|      impl_.Read(&u.value);
  672|     10|    }
  673|     10|    return std::move(u.value);
  674|     10|  }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UC2Ev:
  661|     10|      U() {}
_ZNK4absl12lts_2024011614flags_internal9FlagValueINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELNS1_20FlagValueStorageKindE3EE3GetERKNS1_12SequenceLockERSC_:
  397|     10|  bool Get(const SequenceLock&, T&) const { return false; }
_ZZNK4absl12lts_2024011614flags_internal4FlagINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEE3GetEvEN1UD2Ev:
  662|     10|      ~U() { value.~T(); }
_ZNK4absl12lts_2024011614flags_internal13FlagRegistrarINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEELb1EEcvNS1_18FlagRegistrarEmptyEEv:
  786|      8|  operator FlagRegistrarEmpty() const { return {}; }  // NOLINT

_ZN4absl12lts_2024011614flags_internal21PrivateHandleAccessor9ParseFromERNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_15FlagSettingModeENS1_11ValueSourceERNS5_12basic_stringIcS8_NS5_9allocatorIcEEEE:
   58|      2|                                      std::string& error) {
   59|      2|  return flag.ParseFrom(value, set_mode, source, error);
   60|      2|}

_ZN4absl12lts_2024011614flags_internal21ProgramInvocationNameEv:
   36|      2|std::string ProgramInvocationName() {
   37|      2|  absl::MutexLock l(&program_name_guard);
   38|       |
   39|      2|  return program_name ? *program_name : "UNKNOWN";
  ------------------
  |  Branch (39:10): [True: 0, False: 2]
  ------------------
   40|      2|}
_ZN4absl12lts_2024011614flags_internal24SetProgramInvocationNameENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   49|      2|void SetProgramInvocationName(absl::string_view prog_name_str) {
   50|      2|  absl::MutexLock l(&program_name_guard);
   51|       |
   52|      2|  if (!program_name)
  ------------------
  |  Branch (52:7): [True: 2, False: 0]
  ------------------
   53|      2|    program_name = new std::string(prog_name_str);
   54|      0|  else
   55|      0|    program_name->assign(prog_name_str.data(), prog_name_str.size());
   56|      2|}

_ZNK4absl12lts_2024011614flags_internal12SequenceLock7TryReadEPvPKNSt3__16atomicImEEm:
   80|      8|  bool TryRead(void* dst, const std::atomic<uint64_t>* src, size_t size) const {
   81|       |    // Acquire barrier ensures that no loads done by f() are reordered
   82|       |    // above the first load of the sequence counter.
   83|      8|    int64_t seq_before = lock_.load(std::memory_order_acquire);
   84|      8|    if (ABSL_PREDICT_FALSE(seq_before & 1) == 1) return false;
  ------------------
  |  |  178|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:49): [Folded, False: 8]
  |  |  |  Branch (178:58): [True: 4, False: 4]
  |  |  ------------------
  ------------------
  |  Branch (84:9): [True: 4, False: 4]
  ------------------
   85|      4|    RelaxedCopyFromAtomic(dst, src, size);
   86|       |    // Another acquire fence ensures that the load of 'lock_' below is
   87|       |    // strictly ordered after the RelaxedCopyToAtomic call above.
   88|      4|    std::atomic_thread_fence(std::memory_order_acquire);
   89|      4|    int64_t seq_after = lock_.load(std::memory_order_relaxed);
   90|      4|    return ABSL_PREDICT_TRUE(seq_before == seq_after);
  ------------------
  |  |  179|      4|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (179:48): [Folded, False: 4]
  |  |  |  Branch (179:57): [True: 4, False: 0]
  |  |  ------------------
  ------------------
   91|      8|  }
_ZN4absl12lts_2024011614flags_internal12SequenceLock21RelaxedCopyFromAtomicEPvPKNSt3__16atomicImEEm:
  144|      4|                                    size_t size) {
  145|      4|    char* dst_byte = static_cast<char*>(dst);
  146|      8|    while (size >= sizeof(uint64_t)) {
  ------------------
  |  Branch (146:12): [True: 4, False: 4]
  ------------------
  147|      4|      uint64_t word = src->load(std::memory_order_relaxed);
  148|      4|      std::memcpy(dst_byte, &word, sizeof(word));
  149|      4|      dst_byte += sizeof(word);
  150|      4|      src++;
  151|      4|      size -= sizeof(word);
  152|      4|    }
  153|      4|    if (size > 0) {
  ------------------
  |  Branch (153:9): [True: 4, False: 0]
  ------------------
  154|      4|      uint64_t word = src->load(std::memory_order_relaxed);
  155|      4|      std::memcpy(dst_byte, &word, size);
  156|      4|    }
  157|      4|  }
_ZN4absl12lts_2024011614flags_internal12SequenceLock15MarkInitializedEv:
   63|     24|  void MarkInitialized() {
   64|       |    assert(lock_.load(std::memory_order_relaxed) == kUninitialized);
   65|     24|    lock_.store(0, std::memory_order_release);
   66|     24|  }
_ZN4absl12lts_2024011614flags_internal12SequenceLock26IncrementModificationCountEv:
  134|      2|  void IncrementModificationCount() {
  135|      2|    int64_t val = lock_.load(std::memory_order_relaxed);
  136|       |    assert(val != kUninitialized);
  137|      2|    lock_.store(val + 2, std::memory_order_relaxed);
  138|      2|  }

_ZN4absl12lts_2024011614flags_internal16HandleUsageFlagsERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEENS2_17basic_string_viewIcS5_EE:
  373|      2|                          absl::string_view program_usage_message) {
  374|      2|  switch (GetFlagsHelpMode()) {
  ------------------
  |  Branch (374:11): [True: 2, False: 0]
  ------------------
  375|      2|    case HelpMode::kNone:
  ------------------
  |  Branch (375:5): [True: 2, False: 0]
  ------------------
  376|      2|      break;
  377|      0|    case HelpMode::kImportant:
  ------------------
  |  Branch (377:5): [True: 0, False: 2]
  ------------------
  378|      0|      flags_internal::FlagsHelpImpl(
  379|      0|          out, flags_internal::GetUsageConfig().contains_help_flags,
  380|      0|          GetFlagsHelpFormat(), program_usage_message);
  381|      0|      break;
  382|       |
  383|      0|    case HelpMode::kShort:
  ------------------
  |  Branch (383:5): [True: 0, False: 2]
  ------------------
  384|      0|      flags_internal::FlagsHelpImpl(
  385|      0|          out, flags_internal::GetUsageConfig().contains_helpshort_flags,
  386|      0|          GetFlagsHelpFormat(), program_usage_message);
  387|      0|      break;
  388|       |
  389|      0|    case HelpMode::kFull:
  ------------------
  |  Branch (389:5): [True: 0, False: 2]
  ------------------
  390|      0|      flags_internal::FlagsHelp(out, "", GetFlagsHelpFormat(),
  391|      0|                                program_usage_message);
  392|      0|      break;
  393|       |
  394|      0|    case HelpMode::kPackage:
  ------------------
  |  Branch (394:5): [True: 0, False: 2]
  ------------------
  395|      0|      flags_internal::FlagsHelpImpl(
  396|      0|          out, flags_internal::GetUsageConfig().contains_helppackage_flags,
  397|      0|          GetFlagsHelpFormat(), program_usage_message);
  398|      0|      break;
  399|       |
  400|      0|    case HelpMode::kMatch: {
  ------------------
  |  Branch (400:5): [True: 0, False: 2]
  ------------------
  401|      0|      std::string substr = GetFlagsHelpMatchSubstr();
  402|      0|      if (substr.empty()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 0]
  ------------------
  403|       |        // show all options
  404|      0|        flags_internal::FlagsHelp(out, substr, GetFlagsHelpFormat(),
  405|      0|                                  program_usage_message);
  406|      0|      } else {
  407|      0|        auto filter_cb = [&substr](const absl::CommandLineFlag& flag) {
  408|      0|          if (absl::StrContains(flag.Name(), substr)) return true;
  409|      0|          if (absl::StrContains(flag.Filename(), substr)) return true;
  410|      0|          if (absl::StrContains(flag.Help(), substr)) return true;
  411|       |
  412|      0|          return false;
  413|      0|        };
  414|      0|        flags_internal::FlagsHelpImpl(
  415|      0|            out, filter_cb, HelpFormat::kHumanReadable, program_usage_message);
  416|      0|      }
  417|      0|      break;
  418|      0|    }
  419|      0|    case HelpMode::kVersion:
  ------------------
  |  Branch (419:5): [True: 0, False: 2]
  ------------------
  420|      0|      if (flags_internal::GetUsageConfig().version_string)
  ------------------
  |  Branch (420:11): [True: 0, False: 0]
  ------------------
  421|      0|        out << flags_internal::GetUsageConfig().version_string();
  422|       |      // Unlike help, we may be asking for version in a script, so return 0
  423|      0|      break;
  424|       |
  425|      0|    case HelpMode::kOnlyCheckArgs:
  ------------------
  |  Branch (425:5): [True: 0, False: 2]
  ------------------
  426|      0|      break;
  427|      2|  }
  428|       |
  429|      2|  return GetFlagsHelpMode();
  430|      2|}
_ZN4absl12lts_2024011614flags_internal16GetFlagsHelpModeEv:
  459|      4|HelpMode GetFlagsHelpMode() {
  460|      4|  absl::MutexLock l(&help_attributes_guard);
  461|      4|  return help_mode;
  462|      4|}
_ZN4absl12lts_2024011614flags_internal9MaybeExitENS1_8HelpModeE:
  539|      2|void MaybeExit(HelpMode mode) {
  540|      2|  switch (mode) {
  541|      2|    case flags_internal::HelpMode::kNone:
  ------------------
  |  Branch (541:5): [True: 2, False: 0]
  ------------------
  542|      2|      return;
  543|      0|    case flags_internal::HelpMode::kOnlyCheckArgs:
  ------------------
  |  Branch (543:5): [True: 0, False: 2]
  ------------------
  544|      0|    case flags_internal::HelpMode::kVersion:
  ------------------
  |  Branch (544:5): [True: 0, False: 2]
  ------------------
  545|      0|      std::exit(0);
  546|      0|    default:  // For all the other modes we exit with 1
  ------------------
  |  Branch (546:5): [True: 0, False: 2]
  ------------------
  547|      0|      std::exit(1);
  548|      2|  }
  549|      2|}

_ZN4absl12lts_2024011614flags_internal13AbslParseFlagENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEESB_:
  172|      2|bool AbslParseFlag(absl::string_view text, std::string* dst, std::string*) {
  173|      2|  dst->assign(text.data(), text.size());
  174|      2|  return true;
  175|      2|}

_ZN4absl12lts_202401169ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbNS2_17basic_string_viewIcS5_EEPT_PS8_:
  333|      2|inline bool ParseFlag(absl::string_view input, T* dst, std::string* error) {
  334|      2|  return flags_internal::InvokeParseFlag(input, dst, error);
  335|      2|}
_ZN4absl12lts_2024011614flags_internal15InvokeParseFlagINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbNS3_17basic_string_viewIcS6_EEPT_PS9_:
  275|      2|bool InvokeParseFlag(absl::string_view input, T* dst, std::string* err) {
  276|       |  // Comment on next line provides a good compiler error message if T
  277|       |  // does not have AbslParseFlag(absl::string_view, T*, std::string*).
  278|      2|  return AbslParseFlag(input, dst, err);  // Is T missing AbslParseFlag?
  279|      2|}

_ZN4absl12lts_2024011614flags_internal24ParseAbseilFlagsOnlyImplEiPPcRNSt3__16vectorIS2_NS4_9allocatorIS2_EEEERNS5_INS0_16UnrecognizedFlagENS6_ISA_EEEENS1_16UsageFlagsActionE:
  744|      2|    UsageFlagsAction usage_flag_action) {
  745|      2|  ABSL_INTERNAL_CHECK(argc > 0, "Missing argv[0]");
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  |  |  Branch (178:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  746|       |
  747|      2|  using flags_internal::ArgsList;
  748|      2|  using flags_internal::specified_flags;
  749|       |
  750|      2|  std::vector<std::string> flagfile_value;
  751|      2|  std::vector<ArgsList> input_args;
  752|       |
  753|       |  // Once parsing has started we will not allow more flag registrations.
  754|      2|  flags_internal::FinalizeRegistry();
  755|       |
  756|       |  // This routine does not return anything since we abort on failure.
  757|      2|  flags_internal::CheckDefaultValuesParsingRoundtrip();
  758|       |
  759|      2|  input_args.push_back(ArgsList(argc, argv));
  760|       |
  761|       |  // Set program invocation name if it is not set before.
  762|      2|  if (flags_internal::ProgramInvocationName() == "UNKNOWN") {
  ------------------
  |  Branch (762:7): [True: 2, False: 0]
  ------------------
  763|      2|    flags_internal::SetProgramInvocationName(argv[0]);
  764|      2|  }
  765|      2|  positional_args.push_back(argv[0]);
  766|       |
  767|      2|  absl::MutexLock l(&flags_internal::specified_flags_guard);
  768|      2|  if (specified_flags == nullptr) {
  ------------------
  |  Branch (768:7): [True: 2, False: 0]
  ------------------
  769|      2|    specified_flags = new std::vector<const CommandLineFlag*>;
  770|      2|  } else {
  771|      0|    specified_flags->clear();
  772|      0|  }
  773|       |
  774|       |  // Iterate through the list of the input arguments. First level are
  775|       |  // arguments originated from argc/argv. Following levels are arguments
  776|       |  // originated from recursive parsing of flagfile(s).
  777|      2|  bool success = true;
  778|      4|  while (!input_args.empty()) {
  ------------------
  |  Branch (778:10): [True: 4, False: 0]
  ------------------
  779|       |    // First we process the built-in generator flags.
  780|      4|    success &= flags_internal::HandleGeneratorFlags(input_args, flagfile_value);
  781|       |
  782|       |    // Select top-most (most recent) arguments list. If it is empty drop it
  783|       |    // and re-try.
  784|      4|    ArgsList& curr_list = input_args.back();
  785|       |
  786|       |    // Every ArgsList starts with real or fake program name, so we can always
  787|       |    // start by skipping it.
  788|      4|    curr_list.PopFront();
  789|       |
  790|      4|    if (curr_list.Size() == 0) {
  ------------------
  |  Branch (790:9): [True: 0, False: 4]
  ------------------
  791|      0|      input_args.pop_back();
  792|      0|      continue;
  793|      0|    }
  794|       |
  795|       |    // Handle the next argument in the current list. If the stack of argument
  796|       |    // lists contains only one element - we are processing an argument from
  797|       |    // the original argv.
  798|      4|    absl::string_view arg(curr_list.Front());
  799|      4|    bool arg_from_argv = input_args.size() == 1;
  800|       |
  801|       |    // If argument does not start with '-' or is just "-" - this is
  802|       |    // positional argument.
  803|      4|    if (!absl::ConsumePrefix(&arg, "-") || arg.empty()) {
  ------------------
  |  Branch (803:9): [True: 0, False: 4]
  |  Branch (803:44): [True: 0, False: 4]
  ------------------
  804|      0|      ABSL_INTERNAL_CHECK(arg_from_argv,
  ------------------
  |  |   85|      0|  do {                                                             \
  |  |   86|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  805|      0|                          "Flagfile cannot contain positional argument");
  806|       |
  807|      0|      positional_args.push_back(argv[curr_list.FrontIndex()]);
  808|      0|      continue;
  809|      0|    }
  810|       |
  811|       |    // Split the current argument on '=' to deduce the argument flag name and
  812|       |    // value. If flag name is empty it means we've got an "--" argument. Value
  813|       |    // can be empty either if there were no '=' in argument string at all or
  814|       |    // an argument looked like "--foo=". In a latter case is_empty_value is
  815|       |    // true.
  816|      4|    absl::string_view flag_name;
  817|      4|    absl::string_view value;
  818|      4|    bool is_empty_value = false;
  819|       |
  820|      4|    std::tie(flag_name, value, is_empty_value) =
  821|      4|        flags_internal::SplitNameAndValue(arg);
  822|       |
  823|       |    // Standalone "--" argument indicates that the rest of the arguments are
  824|       |    // positional. We do not support positional arguments in flagfiles.
  825|      4|    if (flag_name.empty()) {
  ------------------
  |  Branch (825:9): [True: 2, False: 2]
  ------------------
  826|      2|      ABSL_INTERNAL_CHECK(arg_from_argv,
  ------------------
  |  |   85|      2|  do {                                                             \
  |  |   86|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  |  |  Branch (178:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  827|      2|                          "Flagfile cannot contain positional argument");
  828|       |
  829|      2|      curr_list.PopFront();
  830|      2|      break;
  831|      2|    }
  832|       |
  833|       |    // Locate the flag based on flag name. Handle both --foo and --nofoo.
  834|      2|    CommandLineFlag* flag = nullptr;
  835|      2|    bool is_negative = false;
  836|      2|    std::tie(flag, is_negative) = flags_internal::LocateFlag(flag_name);
  837|       |
  838|      2|    if (flag == nullptr) {
  ------------------
  |  Branch (838:9): [True: 0, False: 2]
  ------------------
  839|       |      // Usage flags are not modeled as Abseil flags. Locate them separately.
  840|      0|      if (flags_internal::DeduceUsageFlags(flag_name, value)) {
  ------------------
  |  Branch (840:11): [True: 0, False: 0]
  ------------------
  841|      0|        continue;
  842|      0|      }
  843|      0|      unrecognized_flags.emplace_back(arg_from_argv
  ------------------
  |  Branch (843:39): [True: 0, False: 0]
  ------------------
  844|      0|                                          ? UnrecognizedFlag::kFromArgv
  845|      0|                                          : UnrecognizedFlag::kFromFlagfile,
  846|      0|                                      flag_name);
  847|      0|      continue;
  848|      0|    }
  849|       |
  850|       |    // Deduce flag's value (from this or next argument).
  851|      2|    bool value_success = true;
  852|      2|    std::tie(value_success, value) = flags_internal::DeduceFlagValue(
  853|      2|        *flag, value, is_negative, is_empty_value, &curr_list);
  854|      2|    success &= value_success;
  855|       |
  856|       |    // Set the located flag to a new value, unless it is retired. Setting
  857|       |    // retired flag fails, but we ignoring it here while also reporting access
  858|       |    // to retired flag.
  859|      2|    std::string error;
  860|      2|    if (!flags_internal::PrivateHandleAccessor::ParseFrom(
  ------------------
  |  Branch (860:9): [True: 0, False: 2]
  ------------------
  861|      2|            *flag, value, flags_internal::SET_FLAGS_VALUE,
  862|      2|            flags_internal::kCommandLine, error)) {
  863|      0|      if (flag->IsRetired()) continue;
  ------------------
  |  Branch (863:11): [True: 0, False: 0]
  ------------------
  864|       |
  865|      0|      flags_internal::ReportUsageError(error, true);
  866|      0|      success = false;
  867|      2|    } else {
  868|      2|      specified_flags->push_back(flag);
  869|      2|    }
  870|      2|  }
  871|       |
  872|      2|  flags_internal::ResetGeneratorFlags(flagfile_value);
  873|       |
  874|       |  // All the remaining arguments are positional.
  875|      2|  if (!input_args.empty()) {
  ------------------
  |  Branch (875:7): [True: 2, False: 0]
  ------------------
  876|      2|    for (size_t arg_index = input_args.back().FrontIndex();
  877|     11|         arg_index < static_cast<size_t>(argc); ++arg_index) {
  ------------------
  |  Branch (877:10): [True: 9, False: 2]
  ------------------
  878|      9|      positional_args.push_back(argv[arg_index]);
  879|      9|    }
  880|      2|  }
  881|       |
  882|       |  // Trim and sort the vector.
  883|      2|  specified_flags->shrink_to_fit();
  884|      2|  std::sort(specified_flags->begin(), specified_flags->end(),
  885|      2|            flags_internal::SpecifiedFlagsCompare{});
  886|       |
  887|       |  // Filter out unrecognized flags, which are ok to ignore.
  888|      2|  std::vector<UnrecognizedFlag> filtered;
  889|      2|  filtered.reserve(unrecognized_flags.size());
  890|      2|  for (const auto& unrecognized : unrecognized_flags) {
  ------------------
  |  Branch (890:33): [True: 0, False: 2]
  ------------------
  891|      0|    if (flags_internal::CanIgnoreUndefinedFlag(unrecognized.flag_name))
  ------------------
  |  Branch (891:9): [True: 0, False: 0]
  ------------------
  892|      0|      continue;
  893|      0|    filtered.push_back(unrecognized);
  894|      0|  }
  895|       |
  896|      2|  std::swap(unrecognized_flags, filtered);
  897|       |
  898|      2|  if (!success) {
  ------------------
  |  Branch (898:7): [True: 0, False: 2]
  ------------------
  899|       |#if ABSL_FLAGS_STRIP_NAMES
  900|       |    flags_internal::ReportUsageError(
  901|       |        "NOTE: command line flags are disabled in this build", true);
  902|       |#else
  903|      0|    flags_internal::HandleUsageFlags(std::cerr, ProgramUsageMessage());
  904|      0|#endif
  905|      0|    return HelpMode::kFull;  // We just need to make sure the exit with
  906|       |                             // code 1.
  907|      0|  }
  908|       |
  909|      2|  return usage_flag_action == UsageFlagsAction::kHandleUsage
  ------------------
  |  Branch (909:10): [True: 2, False: 0]
  ------------------
  910|      2|             ? flags_internal::HandleUsageFlags(std::cout,
  911|      2|                                                ProgramUsageMessage())
  912|      2|             : HelpMode::kNone;
  913|      2|}
_ZN4absl12lts_2024011620ParseAbseilFlagsOnlyEiPPcRNSt3__16vectorIS1_NS3_9allocatorIS1_EEEERNS4_INS0_16UnrecognizedFlagENS5_IS9_EEEE:
  919|      2|                          std::vector<UnrecognizedFlag>& unrecognized_flags) {
  920|      2|  auto help_mode = flags_internal::ParseAbseilFlagsOnlyImpl(
  921|      2|      argc, argv, positional_args, unrecognized_flags,
  922|      2|      flags_internal::UsageFlagsAction::kHandleUsage);
  923|       |
  924|      2|  flags_internal::MaybeExit(help_mode);
  925|      2|}
parse.cc:_ZNK3$_0clEv:
  106|      2|    .OnUpdate([]() {
  107|      2|      if (absl::GetFlag(FLAGS_flagfile).empty()) return;
  ------------------
  |  Branch (107:11): [True: 2, False: 0]
  ------------------
  108|       |
  109|      0|      absl::MutexLock l(&absl::flags_internal::processing_checks_guard);
  110|       |
  111|       |      // Setting this flag twice before it is handled most likely an internal
  112|       |      // error and should be reviewed by developers.
  113|      0|      if (absl::flags_internal::flagfile_needs_processing) {
  ------------------
  |  Branch (113:11): [True: 0, False: 0]
  ------------------
  114|      0|        ABSL_INTERNAL_LOG(WARNING, "flagfile set twice before it is handled");
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  115|      0|      }
  116|       |
  117|      0|      absl::flags_internal::flagfile_needs_processing = true;
  118|      0|    });
parse.cc:_ZNK3$_1clEv:
  122|      2|    .OnUpdate([]() {
  123|      2|      if (absl::GetFlag(FLAGS_fromenv).empty()) return;
  ------------------
  |  Branch (123:11): [True: 2, False: 0]
  ------------------
  124|       |
  125|      0|      absl::MutexLock l(&absl::flags_internal::processing_checks_guard);
  126|       |
  127|       |      // Setting this flag twice before it is handled most likely an internal
  128|       |      // error and should be reviewed by developers.
  129|      0|      if (absl::flags_internal::fromenv_needs_processing) {
  ------------------
  |  Branch (129:11): [True: 0, False: 0]
  ------------------
  130|      0|        ABSL_INTERNAL_LOG(WARNING, "fromenv set twice before it is handled.");
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  131|      0|      }
  132|       |
  133|      0|      absl::flags_internal::fromenv_needs_processing = true;
  134|      0|    });
parse.cc:_ZNK3$_2clEv:
  138|      2|    .OnUpdate([]() {
  139|      2|      if (absl::GetFlag(FLAGS_tryfromenv).empty()) return;
  ------------------
  |  Branch (139:11): [True: 2, False: 0]
  ------------------
  140|       |
  141|      0|      absl::MutexLock l(&absl::flags_internal::processing_checks_guard);
  142|       |
  143|       |      // Setting this flag twice before it is handled most likely an internal
  144|       |      // error and should be reviewed by developers.
  145|      0|      if (absl::flags_internal::tryfromenv_needs_processing) {
  ------------------
  |  Branch (145:11): [True: 0, False: 0]
  ------------------
  146|      0|        ABSL_INTERNAL_LOG(WARNING,
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  147|      0|                          "tryfromenv set twice before it is handled.");
  148|      0|      }
  149|       |
  150|      0|      absl::flags_internal::tryfromenv_needs_processing = true;
  151|      0|    });
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_134CheckDefaultValuesParsingRoundtripEv:
  322|      2|void CheckDefaultValuesParsingRoundtrip() {
  323|       |#ifndef NDEBUG
  324|       |  flags_internal::ForEachFlag([&](CommandLineFlag& flag) {
  325|       |    if (flag.IsRetired()) return;
  326|       |
  327|       |#define ABSL_FLAGS_INTERNAL_IGNORE_TYPE(T, _) \
  328|       |  if (flag.IsOfType<T>()) return;
  329|       |
  330|       |    ABSL_FLAGS_INTERNAL_SUPPORTED_TYPES(ABSL_FLAGS_INTERNAL_IGNORE_TYPE)
  331|       |#undef ABSL_FLAGS_INTERNAL_IGNORE_TYPE
  332|       |
  333|       |    flags_internal::PrivateHandleAccessor::CheckDefaultValueParsingRoundtrip(
  334|       |        flag);
  335|       |  });
  336|       |#endif
  337|      2|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsListC2EiPPc:
  169|      2|  ArgsList(int argc, char* argv[]) : args_(argv, argv + argc), next_arg_(0) {}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_120HandleGeneratorFlagsERNSt3__16vectorINS2_8ArgsListENS3_9allocatorIS5_EEEERNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS6_IcEEEENS6_ISE_EEEE:
  415|      4|                          std::vector<std::string>& flagfile_value) {
  416|      4|  bool success = true;
  417|       |
  418|      4|  absl::MutexLock l(&flags_internal::processing_checks_guard);
  419|       |
  420|       |  // flagfile could have been set either on a command line or
  421|       |  // programmatically before invoking ParseCommandLine. Note that we do not
  422|       |  // actually process arguments specified in the flagfile, but instead
  423|       |  // create a secondary arguments list to be processed along with the rest
  424|       |  // of the command line arguments. Since we always the process most recently
  425|       |  // created list of arguments first, this will result in flagfile argument
  426|       |  // being processed before any other argument in the command line. If
  427|       |  // FLAGS_flagfile contains more than one file name we create multiple new
  428|       |  // levels of arguments in a reverse order of file names. Thus we always
  429|       |  // process arguments from first file before arguments containing in a
  430|       |  // second file, etc. If flagfile contains another
  431|       |  // --flagfile inside of it, it will produce new level of arguments and
  432|       |  // processed before the rest of the flagfile. We are also collecting all
  433|       |  // flagfiles set on original command line. Unlike the rest of the flags,
  434|       |  // this flag can be set multiple times and is expected to be handled
  435|       |  // multiple times. We are collecting them all into a single list and set
  436|       |  // the value of FLAGS_flagfile to that value at the end of the parsing.
  437|      4|  if (flags_internal::flagfile_needs_processing) {
  ------------------
  |  Branch (437:7): [True: 0, False: 4]
  ------------------
  438|      0|    auto flagfiles = absl::GetFlag(FLAGS_flagfile);
  439|       |
  440|      0|    if (input_args.size() == 1) {
  ------------------
  |  Branch (440:9): [True: 0, False: 0]
  ------------------
  441|      0|      flagfile_value.insert(flagfile_value.end(), flagfiles.begin(),
  442|      0|                            flagfiles.end());
  443|      0|    }
  444|       |
  445|      0|    success &= ReadFlagfiles(flagfiles, input_args);
  446|       |
  447|      0|    flags_internal::flagfile_needs_processing = false;
  448|      0|  }
  449|       |
  450|       |  // Similar to flagfile fromenv/tryfromemv can be set both
  451|       |  // programmatically and at runtime on a command line. Unlike flagfile these
  452|       |  // can't be recursive.
  453|      4|  if (flags_internal::fromenv_needs_processing) {
  ------------------
  |  Branch (453:7): [True: 0, False: 4]
  ------------------
  454|      0|    auto flags_list = absl::GetFlag(FLAGS_fromenv);
  455|       |
  456|      0|    success &= ReadFlagsFromEnv(flags_list, input_args, true);
  457|       |
  458|      0|    flags_internal::fromenv_needs_processing = false;
  459|      0|  }
  460|       |
  461|      4|  if (flags_internal::tryfromenv_needs_processing) {
  ------------------
  |  Branch (461:7): [True: 0, False: 4]
  ------------------
  462|      0|    auto flags_list = absl::GetFlag(FLAGS_tryfromenv);
  463|       |
  464|      0|    success &= ReadFlagsFromEnv(flags_list, input_args, false);
  465|       |
  466|      0|    flags_internal::tryfromenv_needs_processing = false;
  467|      0|  }
  468|       |
  469|      4|  return success;
  470|      4|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList8PopFrontEv:
  179|      6|  void PopFront() { next_arg_++; }
parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList4SizeEv:
  176|      4|  size_t Size() const { return args_.size() - next_arg_; }
parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList5FrontEv:
  178|      4|  absl::string_view Front() const { return args_[next_arg_]; }
parse.cc:_ZNK4absl12lts_2024011614flags_internal12_GLOBAL__N_18ArgsList10FrontIndexEv:
  177|      2|  size_t FrontIndex() const { return next_arg_; }
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_117SplitNameAndValueENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  278|      4|    absl::string_view arg) {
  279|       |  // Allow -foo and --foo
  280|      4|  absl::ConsumePrefix(&arg, "-");
  281|       |
  282|      4|  if (arg.empty()) {
  ------------------
  |  Branch (282:7): [True: 2, False: 2]
  ------------------
  283|      2|    return std::make_tuple("", "", false);
  284|      2|  }
  285|       |
  286|      2|  auto equal_sign_pos = arg.find('=');
  287|       |
  288|      2|  absl::string_view flag_name = arg.substr(0, equal_sign_pos);
  289|       |
  290|      2|  absl::string_view value;
  291|      2|  bool is_empty_value = false;
  292|       |
  293|      2|  if (equal_sign_pos != absl::string_view::npos) {
  ------------------
  |  Branch (293:7): [True: 2, False: 0]
  ------------------
  294|      2|    value = arg.substr(equal_sign_pos + 1);
  295|      2|    is_empty_value = value.empty();
  296|      2|  }
  297|       |
  298|      2|  return std::make_tuple(flag_name, value, is_empty_value);
  299|      4|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_110LocateFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  306|      2|std::tuple<CommandLineFlag*, bool> LocateFlag(absl::string_view flag_name) {
  307|      2|  CommandLineFlag* flag = absl::FindCommandLineFlag(flag_name);
  308|      2|  bool is_negative = false;
  309|       |
  310|      2|  if (!flag && absl::ConsumePrefix(&flag_name, "no")) {
  ------------------
  |  Branch (310:7): [True: 0, False: 2]
  |  Branch (310:16): [True: 0, False: 0]
  ------------------
  311|      0|    flag = absl::FindCommandLineFlag(flag_name);
  312|      0|    is_negative = true;
  313|      0|  }
  314|       |
  315|      2|  return std::make_tuple(flag, is_negative);
  316|      2|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_115DeduceFlagValueERKNS0_15CommandLineFlagENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEbbPNS2_8ArgsListE:
  509|      2|                                                    ArgsList* curr_list) {
  510|       |  // Value is either an argument suffix after `=` in "--foo=<value>"
  511|       |  // or separate argument in case of "--foo" "<value>".
  512|       |
  513|       |  // boolean flags have these forms:
  514|       |  //   --foo
  515|       |  //   --nofoo
  516|       |  //   --foo=true
  517|       |  //   --foo=false
  518|       |  //   --nofoo=<value> is not supported
  519|       |  //   --foo <value> is not supported
  520|       |
  521|       |  // non boolean flags have these forms:
  522|       |  // --foo=<value>
  523|       |  // --foo <value>
  524|       |  // --nofoo is not supported
  525|       |
  526|      2|  if (flag.IsOfType<bool>()) {
  ------------------
  |  Branch (526:7): [True: 0, False: 2]
  ------------------
  527|      0|    if (value.empty()) {
  ------------------
  |  Branch (527:9): [True: 0, False: 0]
  ------------------
  528|      0|      if (is_empty_value) {
  ------------------
  |  Branch (528:11): [True: 0, False: 0]
  ------------------
  529|       |        // "--bool_flag=" case
  530|      0|        flags_internal::ReportUsageError(
  531|      0|            absl::StrCat(
  532|      0|                "Missing the value after assignment for the boolean flag '",
  533|      0|                flag.Name(), "'"),
  534|      0|            true);
  535|      0|        return std::make_tuple(false, "");
  536|      0|      }
  537|       |
  538|       |      // "--bool_flag" case
  539|      0|      value = is_negative ? "0" : "1";
  ------------------
  |  Branch (539:15): [True: 0, False: 0]
  ------------------
  540|      0|    } else if (is_negative) {
  ------------------
  |  Branch (540:16): [True: 0, False: 0]
  ------------------
  541|       |      // "--nobool_flag=Y" case
  542|      0|      flags_internal::ReportUsageError(
  543|      0|          absl::StrCat("Negative form with assignment is not valid for the "
  544|      0|                       "boolean flag '",
  545|      0|                       flag.Name(), "'"),
  546|      0|          true);
  547|      0|      return std::make_tuple(false, "");
  548|      0|    }
  549|      2|  } else if (is_negative) {
  ------------------
  |  Branch (549:14): [True: 0, False: 2]
  ------------------
  550|       |    // "--noint_flag=1" case
  551|      0|    flags_internal::ReportUsageError(
  552|      0|        absl::StrCat("Negative form is not valid for the flag '", flag.Name(),
  553|      0|                     "'"),
  554|      0|        true);
  555|      0|    return std::make_tuple(false, "");
  556|      2|  } else if (value.empty() && (!is_empty_value)) {
  ------------------
  |  Branch (556:14): [True: 0, False: 2]
  |  Branch (556:31): [True: 0, False: 0]
  ------------------
  557|      0|    if (curr_list->Size() == 1) {
  ------------------
  |  Branch (557:9): [True: 0, False: 0]
  ------------------
  558|       |      // "--int_flag" case
  559|      0|      flags_internal::ReportUsageError(
  560|      0|          absl::StrCat("Missing the value for the flag '", flag.Name(), "'"),
  561|      0|          true);
  562|      0|      return std::make_tuple(false, "");
  563|      0|    }
  564|       |
  565|       |    // "--int_flag" "10" case
  566|      0|    curr_list->PopFront();
  567|      0|    value = curr_list->Front();
  568|       |
  569|       |    // Heuristic to detect the case where someone treats a string arg
  570|       |    // like a bool or just forgets to pass a value:
  571|       |    // --my_string_var --foo=bar
  572|       |    // We look for a flag of string type, whose value begins with a
  573|       |    // dash and corresponds to known flag or standalone --.
  574|      0|    if (!value.empty() && value[0] == '-' && flag.IsOfType<std::string>()) {
  ------------------
  |  Branch (574:9): [True: 0, False: 0]
  |  Branch (574:27): [True: 0, False: 0]
  |  Branch (574:46): [True: 0, False: 0]
  ------------------
  575|      0|      auto maybe_flag_name = std::get<0>(SplitNameAndValue(value.substr(1)));
  576|       |
  577|      0|      if (maybe_flag_name.empty() ||
  ------------------
  |  Branch (577:11): [True: 0, False: 0]
  |  Branch (577:11): [True: 0, False: 0]
  ------------------
  578|      0|          std::get<0>(LocateFlag(maybe_flag_name)) != nullptr) {
  ------------------
  |  Branch (578:11): [True: 0, False: 0]
  ------------------
  579|       |        // "--string_flag" "--known_flag" case
  580|      0|        ABSL_INTERNAL_LOG(
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  108|      0|#define ABSL_RAW_LOG_INTERNAL_WARNING ::absl::LogSeverity::kWarning
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  581|      0|            WARNING,
  582|      0|            absl::StrCat("Did you really mean to set flag '", flag.Name(),
  583|      0|                         "' to the value '", value, "'?"));
  584|      0|      }
  585|      0|    }
  586|      0|  }
  587|       |
  588|      2|  return std::make_tuple(true, value);
  589|      2|}
parse.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_119ResetGeneratorFlagsERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE:
  474|      2|void ResetGeneratorFlags(const std::vector<std::string>& flagfile_value) {
  475|       |  // Setting flagfile to the value which collates all the values set on a
  476|       |  // command line and programmatically. So if command line looked like
  477|       |  // --flagfile=f1 --flagfile=f2 the final value of the FLAGS_flagfile flag is
  478|       |  // going to be {"f1", "f2"}
  479|      2|  if (!flagfile_value.empty()) {
  ------------------
  |  Branch (479:7): [True: 0, False: 2]
  ------------------
  480|      0|    absl::SetFlag(&FLAGS_flagfile, flagfile_value);
  481|      0|    absl::MutexLock l(&flags_internal::processing_checks_guard);
  482|      0|    flags_internal::flagfile_needs_processing = false;
  483|      0|  }
  484|       |
  485|       |  // fromenv/tryfromenv are set to <undefined> value.
  486|      2|  if (!absl::GetFlag(FLAGS_fromenv).empty()) {
  ------------------
  |  Branch (486:7): [True: 0, False: 2]
  ------------------
  487|      0|    absl::SetFlag(&FLAGS_fromenv, {});
  488|      0|  }
  489|      2|  if (!absl::GetFlag(FLAGS_tryfromenv).empty()) {
  ------------------
  |  Branch (489:7): [True: 0, False: 2]
  ------------------
  490|      0|    absl::SetFlag(&FLAGS_tryfromenv, {});
  491|      0|  }
  492|       |
  493|      2|  absl::MutexLock l(&flags_internal::processing_checks_guard);
  494|      2|  flags_internal::fromenv_needs_processing = false;
  495|      2|  flags_internal::tryfromenv_needs_processing = false;
  496|      2|}

_ZN4absl12lts_2024011614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   99|      2|CommandLineFlag* FlagRegistry::FindFlag(absl::string_view name) {
  100|      2|  if (finalized_flags_.load(std::memory_order_acquire)) {
  ------------------
  |  Branch (100:7): [True: 2, False: 0]
  ------------------
  101|       |    // We could save some gcus here if we make `Name()` be non-virtual.
  102|       |    // We could move the `const char*` name to the base class.
  103|      2|    auto it = std::partition_point(
  104|      2|        flat_flags_.begin(), flat_flags_.end(),
  105|      2|        [=](CommandLineFlag* f) { return f->Name() < name; });
  106|      2|    if (it != flat_flags_.end() && (*it)->Name() == name) return *it;
  ------------------
  |  Branch (106:9): [True: 2, False: 0]
  |  Branch (106:9): [True: 2, False: 0]
  |  Branch (106:36): [True: 2, False: 0]
  ------------------
  107|      2|  }
  108|       |
  109|      0|  FlagRegistryLock frl(*this);
  110|      0|  auto it = flags_.find(name);
  111|      0|  return it != flags_.end() ? it->second : nullptr;
  ------------------
  |  Branch (111:10): [True: 0, False: 0]
  ------------------
  112|      2|}
_ZN4absl12lts_2024011614flags_internal12FlagRegistry12RegisterFlagERNS0_15CommandLineFlagEPKc:
  114|     26|void FlagRegistry::RegisterFlag(CommandLineFlag& flag, const char* filename) {
  115|     26|  if (filename != nullptr &&
  ------------------
  |  Branch (115:7): [True: 26, False: 0]
  |  Branch (115:7): [True: 0, False: 26]
  ------------------
  116|     26|      flag.Filename() != GetUsageConfig().normalize_filename(filename)) {
  ------------------
  |  Branch (116:7): [True: 0, False: 26]
  ------------------
  117|      0|    flags_internal::ReportUsageError(
  118|      0|        absl::StrCat(
  119|      0|            "Inconsistency between flag object and registration for flag '",
  120|      0|            flag.Name(),
  121|      0|            "', likely due to duplicate flags or an ODR violation. Relevant "
  122|      0|            "files: ",
  123|      0|            flag.Filename(), " and ", filename),
  124|      0|        true);
  125|      0|    std::exit(1);
  126|      0|  }
  127|       |
  128|     26|  FlagRegistryLock registry_lock(*this);
  129|       |
  130|     26|  std::pair<FlagIterator, bool> ins =
  131|     26|      flags_.insert(FlagMap::value_type(flag.Name(), &flag));
  132|     26|  if (ins.second == false) {  // means the name was already in the map
  ------------------
  |  Branch (132:7): [True: 0, False: 26]
  ------------------
  133|      0|    CommandLineFlag& old_flag = *ins.first->second;
  134|      0|    if (flag.IsRetired() != old_flag.IsRetired()) {
  ------------------
  |  Branch (134:9): [True: 0, False: 0]
  ------------------
  135|       |      // All registrations must agree on the 'retired' flag.
  136|      0|      flags_internal::ReportUsageError(
  137|      0|          absl::StrCat(
  138|      0|              "Retired flag '", flag.Name(), "' was defined normally in file '",
  139|      0|              (flag.IsRetired() ? old_flag.Filename() : flag.Filename()), "'."),
  ------------------
  |  Branch (139:16): [True: 0, False: 0]
  ------------------
  140|      0|          true);
  141|      0|    } else if (flags_internal::PrivateHandleAccessor::TypeId(flag) !=
  ------------------
  |  Branch (141:16): [True: 0, False: 0]
  ------------------
  142|      0|               flags_internal::PrivateHandleAccessor::TypeId(old_flag)) {
  143|      0|      flags_internal::ReportUsageError(
  144|      0|          absl::StrCat("Flag '", flag.Name(),
  145|      0|                       "' was defined more than once but with "
  146|      0|                       "differing types. Defined in files '",
  147|      0|                       old_flag.Filename(), "' and '", flag.Filename(), "'."),
  148|      0|          true);
  149|      0|    } else if (old_flag.IsRetired()) {
  ------------------
  |  Branch (149:16): [True: 0, False: 0]
  ------------------
  150|      0|      return;
  151|      0|    } else if (old_flag.Filename() != flag.Filename()) {
  ------------------
  |  Branch (151:16): [True: 0, False: 0]
  ------------------
  152|      0|      flags_internal::ReportUsageError(
  153|      0|          absl::StrCat("Flag '", flag.Name(),
  154|      0|                       "' was defined more than once (in files '",
  155|      0|                       old_flag.Filename(), "' and '", flag.Filename(), "')."),
  156|      0|          true);
  157|      0|    } else {
  158|      0|      flags_internal::ReportUsageError(
  159|      0|          absl::StrCat(
  160|      0|              "Something is wrong with flag '", flag.Name(), "' in file '",
  161|      0|              flag.Filename(), "'. One possibility: file '", flag.Filename(),
  162|      0|              "' is being linked both statically and dynamically into this "
  163|      0|              "executable. e.g. some files listed as srcs to a test and also "
  164|      0|              "listed as srcs of some shared lib deps of the same test."),
  165|      0|          true);
  166|      0|    }
  167|       |    // All cases above are fatal, except for the retired flags.
  168|      0|    std::exit(1);
  169|      0|  }
  170|     26|}
_ZN4absl12lts_2024011614flags_internal12FlagRegistry14GlobalRegistryEv:
  172|     30|FlagRegistry& FlagRegistry::GlobalRegistry() {
  173|     30|  static absl::NoDestructor<FlagRegistry> global_registry;
  174|     30|  return *global_registry;
  175|     30|}
_ZN4absl12lts_2024011614flags_internal23RegisterCommandLineFlagERNS0_15CommandLineFlagEPKc:
  192|     26|bool RegisterCommandLineFlag(CommandLineFlag& flag, const char* filename) {
  193|     26|  FlagRegistry::GlobalRegistry().RegisterFlag(flag, filename);
  194|     26|  return true;
  195|     26|}
_ZN4absl12lts_2024011614flags_internal16FinalizeRegistryEv:
  197|      2|void FinalizeRegistry() {
  198|      2|  auto& registry = FlagRegistry::GlobalRegistry();
  199|      2|  FlagRegistryLock frl(registry);
  200|      2|  if (registry.finalized_flags_.load(std::memory_order_relaxed)) {
  ------------------
  |  Branch (200:7): [True: 0, False: 2]
  ------------------
  201|       |    // Was already finalized. Ignore the second time.
  202|      0|    return;
  203|      0|  }
  204|      2|  registry.flat_flags_.reserve(registry.flags_.size());
  205|     26|  for (const auto& f : registry.flags_) {
  ------------------
  |  Branch (205:22): [True: 26, False: 2]
  ------------------
  206|     26|    registry.flat_flags_.push_back(f.second);
  207|     26|  }
  208|      2|  std::sort(std::begin(registry.flat_flags_), std::end(registry.flat_flags_),
  209|      2|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  210|      2|              return lhs->Name() < rhs->Name();
  211|      2|            });
  212|      2|  registry.flags_.clear();
  213|      2|  registry.finalized_flags_.store(true, std::memory_order_release);
  214|      2|}
_ZN4absl12lts_2024011619FindCommandLineFlagENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  337|      2|CommandLineFlag* FindCommandLineFlag(absl::string_view name) {
  338|      2|  if (name.empty()) return nullptr;
  ------------------
  |  Branch (338:7): [True: 0, False: 2]
  ------------------
  339|      2|  flags_internal::FlagRegistry& registry =
  340|      2|      flags_internal::FlagRegistry::GlobalRegistry();
  341|      2|  return registry.FindFlag(name);
  342|      2|}
reflection.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_116FlagRegistryLockC2ERNS1_12FlagRegistryE:
   90|     28|  explicit FlagRegistryLock(FlagRegistry& fr) : fr_(fr) { fr_.Lock(); }
_ZN4absl12lts_2024011614flags_internal12FlagRegistry4LockEv:
   56|     28|  void Lock() ABSL_EXCLUSIVE_LOCK_FUNCTION(lock_) { lock_.Lock(); }
reflection.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_116FlagRegistryLockD2Ev:
   91|     28|  ~FlagRegistryLock() { fr_.Unlock(); }
_ZN4absl12lts_2024011614flags_internal12FlagRegistry6UnlockEv:
   57|     28|  void Unlock() ABSL_UNLOCK_FUNCTION(lock_) { lock_.Unlock(); }
_ZN4absl12lts_2024011614flags_internal12FlagRegistryC2Ev:
   50|      2|  FlagRegistry() = default;
reflection.cc:_ZZN4absl12lts_2024011614flags_internal12FlagRegistry8FindFlagENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENK3$_0clEPNS0_15CommandLineFlagE:
  105|      8|        [=](CommandLineFlag* f) { return f->Name() < name; });
reflection.cc:_ZZN4absl12lts_2024011614flags_internal16FinalizeRegistryEvENK3$_0clEPKNS0_15CommandLineFlagES5_:
  209|     80|            [](const CommandLineFlag* lhs, const CommandLineFlag* rhs) {
  210|     80|              return lhs->Name() < rhs->Name();
  211|     80|            });

_ZN4absl12lts_2024011619ProgramUsageMessageEv:
   57|      2|absl::string_view ProgramUsageMessage() {
   58|      2|  absl::MutexLock l(&flags_internal::usage_message_guard);
   59|       |
   60|      2|  return flags_internal::program_usage_message != nullptr
  ------------------
  |  Branch (60:10): [True: 0, False: 2]
  ------------------
   61|      2|             ? absl::string_view(*flags_internal::program_usage_message)
   62|      2|             : "Warning: SetProgramUsageMessage() never called";
   63|      2|}

_ZN4absl12lts_2024011614flags_internal14GetUsageConfigEv:
  113|     52|FlagsUsageConfig GetUsageConfig() {
  114|     52|  absl::MutexLock l(&custom_usage_config_guard);
  115|       |
  116|     52|  if (custom_usage_config) return *custom_usage_config;
  ------------------
  |  Branch (116:7): [True: 0, False: 52]
  ------------------
  117|       |
  118|     52|  FlagsUsageConfig default_config;
  119|     52|  default_config.contains_helpshort_flags = &ContainsHelpshortFlags;
  120|     52|  default_config.contains_help_flags = &ContainsHelppackageFlags;
  121|     52|  default_config.contains_helppackage_flags = &ContainsHelppackageFlags;
  122|     52|  default_config.version_string = &VersionString;
  123|     52|  default_config.normalize_filename = &NormalizeFilename;
  124|       |
  125|     52|  return default_config;
  126|     52|}
usage_config.cc:_ZN4absl12lts_2024011614flags_internal12_GLOBAL__N_117NormalizeFilenameENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   96|     52|std::string NormalizeFilename(absl::string_view filename) {
   97|       |  // Skip any leading slashes
   98|     52|  auto pos = filename.find_first_not_of("\\/");
   99|     52|  if (pos == absl::string_view::npos) return "";
  ------------------
  |  Branch (99:7): [True: 0, False: 52]
  ------------------
  100|       |
  101|     52|  filename.remove_prefix(pos);
  102|     52|  return std::string(filename);
  103|     52|}

_ZN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2IZNS5_17RegistrationToken24GetFuzzTestFuzzerFactoryINS5_27RegistrationWithDomainsBaseIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEENS5_9NoFixtureEPFvNS2_17basic_string_viewIcSL_EEEPvEESE_ONS5_12RegistrationIT0_T1_T_T2_EEEUlSC_E_vEEOSZ_:
  186|      2|      : Impl(internal_any_invocable::ConversionConstruct(),
  187|      2|             std::forward<F>(f)) {}
_ZN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS2_14default_deleteIS6_EEEERKNS5_8FuzzTestEEEC2EOSE_:
  176|      4|  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;

init_fuzztest.cc:_ZN4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS2_19ListRegisteredTestsEvE3$_0vEERKT_:
  105|      4|      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
  106|      4|    absl::functional_internal::AssertNonNull(f);
  107|      4|    ptr_.obj = &f;
  108|      4|  }
googletest_adaptor.cc:_ZN4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEC2IZNS3_30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS3_13ConfigurationEE3$_0vEERKT_:
  105|      2|      : invoker_(&absl::functional_internal::InvokeObject<F, R, Args...>) {
  106|      2|    absl::functional_internal::AssertNonNull(f);
  107|      2|    ptr_.obj = &f;
  108|      2|  }
_ZNK4absl12lts_2024011611FunctionRefIFvRN8fuzztest8internal8FuzzTestEEEclES5_:
  131|      6|  R operator()(Args... args) const {
  132|      6|    return invoker_(ptr_, std::forward<Args>(args)...);
  133|      6|  }

_ZN4absl12lts_2024011622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEEC2IZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSM_EEEPvEENS0_12AnyInvocableISE_EEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_EENS1_19ConversionConstructEOS12_:
  813|      2|        : Core(TypedConversionConstruct<                                       \
  814|      2|                   typename std::decay<F>::type inv_quals>(),                  \
  815|      2|               std::forward<F>(f)) {}                                          \
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2IRKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSL_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_S16_EENS1_24TypedConversionConstructIS12_EEOS10_:
  454|      2|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  455|      2|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  456|       |
  457|      2|    constexpr TargetType kTargetType =
  458|      2|        (std::is_pointer<DecayedT>::value ||
  ------------------
  |  Branch (458:10): [Folded, False: 0]
  ------------------
  459|      0|         std::is_member_pointer<DecayedT>::value)
  ------------------
  |  Branch (459:10): [Folded, False: 0]
  ------------------
  460|      2|            ? TargetType::kPointer
  461|      2|        : IsCompatibleAnyInvocable<DecayedT>::value
  ------------------
  |  Branch (461:11): [Folded, False: 2]
  ------------------
  462|      2|            ? TargetType::kCompatibleAnyInvocable
  463|      2|        : IsAnyInvocable<DecayedT>::value
  ------------------
  |  Branch (463:11): [Folded, False: 2]
  ------------------
  464|      2|            ? TargetType::kIncompatibleAnyInvocable
  465|      2|            : TargetType::kOther;
  466|       |    // NOTE: We only use integers instead of enums as template parameters in
  467|       |    // order to work around a bug on C++14 under MSVC 2017.
  468|       |    // See b/236131881.
  469|      2|    Initialize<kTargetType, QualDecayedTRef>(std::forward<F>(f));
  470|      2|  }
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE10InitializeILNSE_10TargetTypeE3ERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSM_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_S17_vEEvOS12_:
  572|      2|  void Initialize(F&& f) {
  573|      2|    InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  574|      2|  }
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE17InitializeStorageIRKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSL_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_JS16_ETnNS3_9enable_ifIXntsr15IsStoredLocallyINS3_9remove_cvINS3_16remove_referenceIS12_E4typeEE4typeEEE5valueEiE4typeELi0EEEvDpOT0_:
  594|      2|  void InitializeStorage(Args&&... args) {
  595|      2|    InitializeRemoteManager<RemoveCVRef<QualTRef>>(std::forward<Args>(args)...);
  596|       |    // This is set after everything else in case an exception is thrown in an
  597|       |    // earlier step of the initialization.
  598|      2|    invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  599|      2|  }
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEE23InitializeRemoteManagerIZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSL_EEEPvEENS0_12AnyInvocableIKFSA_SD_EEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSD_E_JS16_ETnNS3_9enable_ifIXntsr23HasTrivialRemoteStorageIS12_EE5valueEiE4typeELi0EEEvDpOT0_:
  633|      2|  void InitializeRemoteManager(Args&&... args) {
  634|      2|    state_.remote.target = ::new T(std::forward<Args>(args)...);
  635|      2|    manager_ = RemoteManagerNontrivial<T>;
  636|      2|  }
_ZN4absl12lts_2024011622internal_any_invocable23RemoteManagerNontrivialIZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS4_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEENS4_9NoFixtureEPFvNS8_17basic_string_viewIcSB_EEEPvEENS0_12AnyInvocableIKFNS8_10unique_ptrINS4_14FuzzTestFuzzerENS8_14default_deleteISO_EEEERKNS4_8FuzzTestEEEEONS4_12RegistrationIT0_T1_T_T2_EEEUlSU_E_EEvNS1_14FunctionToCallEPNS1_15TypeErasedStateES17_:
  340|      4|                             TypeErasedState* const to) noexcept {
  341|      4|  static_assert(!IsStoredLocally<T>::value,
  342|      4|                "Remote storage must only be used for types that do not "
  343|      4|                "qualify for local storage.");
  344|       |
  345|      4|  switch (operation) {
  ------------------
  |  Branch (345:11): [True: 4, False: 0]
  ------------------
  346|      4|    case FunctionToCall::relocate_from_to:
  ------------------
  |  Branch (346:5): [True: 4, False: 0]
  ------------------
  347|       |      // NOTE: Requires that the left-hand operand is already empty.
  348|      4|      to->remote.target = from->remote.target;
  349|      4|      return;
  350|      0|    case FunctionToCall::dispose:
  ------------------
  |  Branch (350:5): [True: 0, False: 4]
  ------------------
  351|      0|      ::delete static_cast<T*>(from->remote.target);  // Must not throw.
  352|      0|      return;
  353|      4|  }
  354|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  225|      0|  do {                                           \
  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  229|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  355|      0|}
_ZN4absl12lts_2024011622internal_any_invocable13RemoteInvokerILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSG_EEEPvEENS0_12AnyInvocableIKFSA_RKNS6_8FuzzTestEEEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSU_E_JSU_EEESY_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  361|      2|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  362|      2|  using RawT = RemoveCVRef<QualTRef>;
  363|      2|  static_assert(!IsStoredLocally<RawT>::value,
  364|      2|                "Target object must be in remote storage in order to be "
  365|      2|                "invoked from it.");
  366|       |
  367|      2|  auto& f = *static_cast<RawT*>(state->remote.target);
  368|      2|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  369|      2|                               static_cast<ForwardedParameterType<P>>(args)...);
  370|      2|}
_ZN4absl12lts_2024011622internal_any_invocable7InvokeRINSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKZNS6_17RegistrationToken24GetFuzzTestFuzzerFactoryINS6_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEENS6_9NoFixtureEPFvNS3_17basic_string_viewIcSG_EEEPvEENS0_12AnyInvocableIKFSA_RKNS6_8FuzzTestEEEEONS6_12RegistrationIT0_T1_T_T2_EEEUlSU_E_JSU_ETnNS3_9enable_ifIXntsr3std7is_voidIS10_EE5valueEiE4typeELi0EEES10_OSY_DpOT1_:
  137|      2|ReturnType InvokeR(F&& f, P&&... args) {
  138|       |  // GCC 12 has a false-positive -Wmaybe-uninitialized warning here.
  139|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
  140|       |#pragma GCC diagnostic push
  141|       |#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  142|       |#endif
  143|      2|  return absl::base_internal::invoke(std::forward<F>(f),
  144|      2|                                     std::forward<P>(args)...);
  145|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
  146|       |#pragma GCC diagnostic pop
  147|       |#endif
  148|      2|}
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEED2Ev:
  508|      4|  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
_ZN4absl12lts_2024011622internal_any_invocable12EmptyManagerENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  246|      4|                         TypeErasedState* /*to*/) noexcept {}
_ZNK4absl12lts_2024011622internal_any_invocable4ImplIKFNSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEERKNS6_8FuzzTestEEE14ExtractInvokerEv:
  831|      2|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  832|      2|      using QualifiedTestType = int cv ref;                                    \
  833|      2|      auto* invoker = this->invoker_;                                          \
  834|      2|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (834:11): [Folded, False: 2]
  ------------------
  835|      2|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (835:11): [Folded, False: 0]
  ------------------
  836|      0|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |   95|      0|  (false ? static_cast<void>(expr) : static_cast<void>(0))
  |  |  ------------------
  |  |  |  Branch (95:4): [Folded, False: 0]
  |  |  ------------------
  ------------------
  837|      0|          /* We checked that this isn't const above, so const_cast is safe */  \
  838|      0|          const_cast<Impl*>(this)->invoker_ = InvokedAfterMove;                \
  839|      0|          return this->HasValue();                                             \
  840|      0|        }());                                                                  \
  841|      0|      }                                                                        \
  842|      2|      return invoker;                                                          \
  843|      2|    }                                                                          \
_ZN4absl12lts_2024011622internal_any_invocable8CoreImplILb0ENSt3__110unique_ptrIN8fuzztest8internal14FuzzTestFuzzerENS3_14default_deleteIS7_EEEEJRKNS6_8FuzzTestEEEC2EOSE_:
  480|      4|  CoreImpl(CoreImpl&& other) noexcept {
  481|      4|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  482|      4|    manager_ = other.manager_;
  483|      4|    invoker_ = other.invoker_;
  484|      4|    other.manager_ = EmptyManager;
  485|      4|    other.invoker_ = nullptr;
  486|      4|  }

init_fuzztest.cc:_ZN4absl12lts_2024011619functional_internal12InvokeObjectIZN8fuzztest19ListRegisteredTestsEvE3$_0vJRNS3_8internal8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   75|      4|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   76|      4|  auto o = static_cast<const Obj*>(ptr.obj);
   77|      4|  return static_cast<R>(
   78|      4|      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
   79|      4|}
init_fuzztest.cc:_ZN4absl12lts_2024011619functional_internal13AssertNonNullIZN8fuzztest19ListRegisteredTestsEvE3$_0EEvRKT_:
  101|      4|void AssertNonNull(const F&) {}
googletest_adaptor.cc:_ZN4absl12lts_2024011619functional_internal12InvokeObjectIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0vJRNS4_8FuzzTestEEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   75|      2|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   76|      2|  auto o = static_cast<const Obj*>(ptr.obj);
   77|      2|  return static_cast<R>(
   78|      2|      absl::base_internal::invoke(*o, std::forward<Args>(args)...));
   79|      2|}
googletest_adaptor.cc:_ZN4absl12lts_2024011619functional_internal13AssertNonNullIZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS4_13ConfigurationEE3$_0EEvRKT_:
  101|      2|void AssertNonNull(const F&) {}

_ZN4absl12lts_2024011613hash_internal15MixingHashState16LowLevelHashImplEPKhm:
   63|      6|                                           size_t len) {
   64|      6|  return LowLevelHash(data, len, Seed(), kHashSalt);
   65|      6|}

_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  234|     52|  static H combine(H state) { return state; }
_ZN4absl12lts_2024011613hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  557|     26|H AbslHashValue(H hash_state, absl::string_view str) {
  558|     26|  return H::combine(
  559|     26|      H::combine_contiguous(std::move(hash_state), str.data(), str.size()),
  560|     26|      str.size());
  561|     26|}
_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_:
 1310|     26|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1311|     26|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1312|     26|                        std::move(state), value),
 1313|     26|                    values...);
 1314|     26|}
_ZN4absl12lts_2024011613hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_:
  927|     26|        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
  928|     26|      return hash_internal::hash_bytes(std::move(state), value);
  929|     26|    }
_ZN4absl12lts_2024011613hash_internal10hash_bytesINS1_15MixingHashStateEmEET_S4_RKT0_:
  340|     26|H hash_bytes(H hash_state, const T& value) {
  341|     26|  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
  342|     26|  return H::combine_contiguous(std::move(hash_state), start, sizeof(value));
  343|     26|}
_ZN4absl12lts_2024011613hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1023|     52|                                            size_t size) {
 1024|     52|    return MixingHashState(
 1025|     52|        CombineContiguousImpl(hash_state.state_, first, size,
 1026|     52|                              std::integral_constant<int, sizeof(size_t)>{}));
 1027|     52|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1247|     52|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1248|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1249|       |  // for small ones we just use a multiplicative hash.
 1250|     52|  uint64_t v;
 1251|     52|  if (len > 16) {
  ------------------
  |  Branch (1251:7): [True: 6, False: 46]
  ------------------
 1252|      6|    if (ABSL_PREDICT_FALSE(len > PiecewiseChunkSize())) {
  ------------------
  |  |  178|      6|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 6]
  |  |  |  Branch (178:49): [Folded, False: 6]
  |  |  |  Branch (178:58): [True: 0, False: 6]
  |  |  ------------------
  ------------------
 1253|      0|      return CombineLargeContiguousImpl64(state, first, len);
 1254|      0|    }
 1255|      6|    v = Hash64(first, len);
 1256|     46|  } else if (len > 8) {
  ------------------
  |  Branch (1256:14): [True: 10, False: 36]
  ------------------
 1257|       |    // This hash function was constructed by the ML-driven algorithm discovery
 1258|       |    // using reinforcement learning. We fed the agent lots of inputs from
 1259|       |    // microbenchmarks, SMHasher, low hamming distance from generated inputs and
 1260|       |    // picked up the one that was good on micro and macrobenchmarks.
 1261|     10|    auto p = Read9To16(first, len);
 1262|     10|    uint64_t lo = p.first;
 1263|     10|    uint64_t hi = p.second;
 1264|       |    // Rotation by 53 was found to be most often useful when discovering these
 1265|       |    // hashing algorithms with ML techniques.
 1266|     10|    lo = absl::rotr(lo, 53);
 1267|     10|    state += kMul;
 1268|     10|    lo += state;
 1269|     10|    state ^= hi;
 1270|     10|    uint128 m = state;
 1271|     10|    m *= lo;
 1272|     10|    return static_cast<uint64_t>(m ^ (m >> 64));
 1273|     36|  } else if (len >= 4) {
  ------------------
  |  Branch (1273:14): [True: 36, False: 0]
  ------------------
 1274|     36|    v = Read4To8(first, len);
 1275|     36|  } else if (len > 0) {
  ------------------
  |  Branch (1275:14): [True: 0, False: 0]
  ------------------
 1276|      0|    v = Read1To3(first, len);
 1277|      0|  } else {
 1278|       |    // Empty ranges have no effect.
 1279|      0|    return state;
 1280|      0|  }
 1281|     42|  return Mix(state, v);
 1282|     52|}
_ZN4absl12lts_2024011613hash_internal18PiecewiseChunkSizeEv:
   82|      6|constexpr size_t PiecewiseChunkSize() { return 1024; }
_ZN4absl12lts_2024011613hash_internal15MixingHashState6Hash64EPKhm:
 1181|      6|                                                      size_t len) {
 1182|      6|#ifdef ABSL_HAVE_INTRINSIC_INT128
 1183|      6|    return LowLevelHashImpl(data, len);
 1184|       |#else
 1185|       |    return hash_internal::CityHash64(reinterpret_cast<const char*>(data), len);
 1186|       |#endif
 1187|      6|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState9Read9To16EPKhm:
 1114|     10|                                                 size_t len) {
 1115|     10|    uint64_t low_mem = absl::base_internal::UnalignedLoad64(p);
 1116|     10|    uint64_t high_mem = absl::base_internal::UnalignedLoad64(p + len - 8);
 1117|     10|#ifdef ABSL_IS_LITTLE_ENDIAN
 1118|     10|    uint64_t most_significant = high_mem;
 1119|     10|    uint64_t least_significant = low_mem;
 1120|       |#else
 1121|       |    uint64_t most_significant = low_mem;
 1122|       |    uint64_t least_significant = high_mem;
 1123|       |#endif
 1124|     10|    return {least_significant, most_significant};
 1125|     10|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState8Read4To8EPKhm:
 1128|     36|  static uint64_t Read4To8(const unsigned char* p, size_t len) {
 1129|     36|    uint32_t low_mem = absl::base_internal::UnalignedLoad32(p);
 1130|     36|    uint32_t high_mem = absl::base_internal::UnalignedLoad32(p + len - 4);
 1131|     36|#ifdef ABSL_IS_LITTLE_ENDIAN
 1132|     36|    uint32_t most_significant = high_mem;
 1133|     36|    uint32_t least_significant = low_mem;
 1134|       |#else
 1135|       |    uint32_t most_significant = low_mem;
 1136|       |    uint32_t least_significant = high_mem;
 1137|       |#endif
 1138|     36|    return (static_cast<uint64_t>(most_significant) << (len - 4) * 8) |
 1139|     36|           least_significant;
 1140|     36|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState3MixEmm:
 1162|     42|  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Mix(uint64_t state, uint64_t v) {
 1163|       |    // Though the 128-bit product on AArch64 needs two instructions, it is
 1164|       |    // still a good balance between speed and hash quality.
 1165|     42|    using MultType =
 1166|     42|        absl::conditional_t<sizeof(size_t) == 4, uint64_t, uint128>;
 1167|       |    // We do the addition in 64-bit space to make sure the 128-bit
 1168|       |    // multiplication is fast. If we were to do it as MultType the compiler has
 1169|       |    // to assume that the high word is non-zero and needs to perform 2
 1170|       |    // multiplications instead of one.
 1171|     42|    MultType m = state + v;
 1172|     42|    m *= kMul;
 1173|     42|    return static_cast<uint64_t>(m ^ (m >> (sizeof(m) * 8 / 2)));
 1174|     42|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashStateC2Em:
 1085|     52|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1319|     26|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1320|     26|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1321|     26|}
_ZN4absl12lts_2024011613hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  885|     26|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  886|     26|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  887|     26|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  888|     26|}
_ZN4absl12lts_2024011613hash_internal15MixingHashStateC2Ev:
 1052|     26|  MixingHashState() : state_(Seed()) {}
_ZN4absl12lts_2024011613hash_internal15MixingHashState4SeedEv:
 1205|     32|  ABSL_ATTRIBUTE_ALWAYS_INLINE static uint64_t Seed() {
 1206|     32|#if (!defined(__clang__) || __clang_major__ > 11) && \
 1207|     32|    (!defined(__apple_build_version__) ||            \
 1208|     32|     __apple_build_version__ >= 19558921)  // Xcode 12
 1209|     32|    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(&kSeed));
 1210|       |#else
 1211|       |    // Workaround the absence of
 1212|       |    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
 1213|       |    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(kSeed));
 1214|       |#endif
 1215|     32|  }
_ZNK4absl12lts_2024011613hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEclERKS7_:
 1299|     26|  size_t operator()(const T& value) const {
 1300|     26|    return MixingHashState::hash(value);
 1301|     26|  }
_ZN4absl12lts_2024011613hash_internal15MixingHashState4hashINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_:
 1045|     26|  static size_t hash(const T& value) {
 1046|     26|    return static_cast<size_t>(combine(MixingHashState{}, value).state_);
 1047|     26|  }
_ZN4absl12lts_2024011613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1310|     26|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1311|     26|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1312|     26|                        std::move(state), value),
 1313|     26|                    values...);
 1314|     26|}
_ZN4absl12lts_2024011613hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
  937|     26|        H> {
  938|     26|      return AbslHashValue(std::move(state), value);
  939|     26|    }

_ZN4absl12lts_2024011613hash_internal12LowLevelHashEPKvmmPKm:
   32|      6|                      const uint64_t salt[5]) {
   33|       |  // Prefetch the cacheline that data resides in.
   34|      6|  PrefetchToLocalCache(data);
   35|      6|  const uint8_t* ptr = static_cast<const uint8_t*>(data);
   36|      6|  uint64_t starting_length = static_cast<uint64_t>(len);
   37|      6|  uint64_t current_state = seed ^ salt[0];
   38|       |
   39|      6|  if (len > 64) {
  ------------------
  |  Branch (39:7): [True: 0, False: 6]
  ------------------
   40|       |    // If we have more than 64 bytes, we're going to handle chunks of 64
   41|       |    // bytes at a time. We're going to build up two separate hash states
   42|       |    // which we will then hash together.
   43|      0|    uint64_t duplicated_state = current_state;
   44|       |
   45|      0|    do {
   46|       |      // Always prefetch the next cacheline.
   47|      0|      PrefetchToLocalCache(ptr + ABSL_CACHELINE_SIZE);
  ------------------
  |  |   77|      0|#define ABSL_CACHELINE_SIZE 64
  ------------------
   48|       |
   49|      0|      uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
   50|      0|      uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
   51|      0|      uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
   52|      0|      uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
   53|      0|      uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
   54|      0|      uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
   55|      0|      uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
   56|      0|      uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
   57|       |
   58|      0|      uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state);
   59|      0|      uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state);
   60|      0|      current_state = (cs0 ^ cs1);
   61|       |
   62|      0|      uint64_t ds0 = Mix(e ^ salt[3], f ^ duplicated_state);
   63|      0|      uint64_t ds1 = Mix(g ^ salt[4], h ^ duplicated_state);
   64|      0|      duplicated_state = (ds0 ^ ds1);
   65|       |
   66|      0|      ptr += 64;
   67|      0|      len -= 64;
   68|      0|    } while (len > 64);
  ------------------
  |  Branch (68:14): [True: 0, False: 0]
  ------------------
   69|       |
   70|      0|    current_state = current_state ^ duplicated_state;
   71|      0|  }
   72|       |
   73|       |  // We now have a data `ptr` with at most 64 bytes and the current state
   74|       |  // of the hashing state machine stored in current_state.
   75|     14|  while (len > 16) {
  ------------------
  |  Branch (75:10): [True: 8, False: 6]
  ------------------
   76|      8|    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
   77|      8|    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
   78|       |
   79|      8|    current_state = Mix(a ^ salt[1], b ^ current_state);
   80|       |
   81|      8|    ptr += 16;
   82|      8|    len -= 16;
   83|      8|  }
   84|       |
   85|       |  // We now have a data `ptr` with at most 16 bytes.
   86|      6|  uint64_t a = 0;
   87|      6|  uint64_t b = 0;
   88|      6|  if (len > 8) {
  ------------------
  |  Branch (88:7): [True: 0, False: 6]
  ------------------
   89|       |    // When we have at least 9 and at most 16 bytes, set A to the first 64
   90|       |    // bits of the input and B to the last 64 bits of the input. Yes, they will
   91|       |    // overlap in the middle if we are working with less than the full 16
   92|       |    // bytes.
   93|      0|    a = absl::base_internal::UnalignedLoad64(ptr);
   94|      0|    b = absl::base_internal::UnalignedLoad64(ptr + len - 8);
   95|      6|  } else if (len > 3) {
  ------------------
  |  Branch (95:14): [True: 6, False: 0]
  ------------------
   96|       |    // If we have at least 4 and at most 8 bytes, set A to the first 32
   97|       |    // bits and B to the last 32 bits.
   98|      6|    a = absl::base_internal::UnalignedLoad32(ptr);
   99|      6|    b = absl::base_internal::UnalignedLoad32(ptr + len - 4);
  100|      6|  } else if (len > 0) {
  ------------------
  |  Branch (100:14): [True: 0, False: 0]
  ------------------
  101|       |    // If we have at least 1 and at most 3 bytes, read all of the provided
  102|       |    // bits into A, with some adjustments.
  103|      0|    a = static_cast<uint64_t>((ptr[0] << 16) | (ptr[len >> 1] << 8) |
  104|      0|                              ptr[len - 1]);
  105|      0|    b = 0;
  106|      0|  } else {
  107|      0|    a = 0;
  108|      0|    b = 0;
  109|      0|  }
  110|       |
  111|      6|  uint64_t w = Mix(a ^ salt[1], b ^ current_state);
  112|      6|  uint64_t z = salt[1] ^ starting_length;
  113|      6|  return Mix(w, z);
  114|      6|}
low_level_hash.cc:_ZN4absl12lts_2024011613hash_internalL3MixEmm:
   25|     20|static uint64_t Mix(uint64_t v0, uint64_t v1) {
   26|     20|  absl::uint128 p = v0;
   27|     20|  p *= v1;
   28|     20|  return absl::Uint128Low64(p) ^ absl::Uint128High64(p);
   29|     20|}

_ZN4absl12lts_2024011611countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  103|  21.8k|    countl_zero(T x) noexcept {
  104|  21.8k|  return numeric_internal::CountLeadingZeroes(x);
  105|  21.8k|}
_ZN4absl12lts_202401164rotrImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueES4_E4typeES4_i:
   75|     10|    rotr(T x, int s) noexcept {
   76|     10|  return numeric_internal::RotateRight(x, s);
   77|     10|}
_ZN4absl12lts_2024011611countr_zeroItEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  118|     27|    countr_zero(T x) noexcept {
  119|     27|  return numeric_internal::CountTrailingZeroes(x);
  120|     27|}
_ZN4absl12lts_2024011611countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  118|      4|    countr_zero(T x) noexcept {
  119|      4|  return numeric_internal::CountTrailingZeroes(x);
  120|      4|}
_ZN4absl12lts_202401169bit_widthImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  160|  4.53k|    bit_width(T x) noexcept {
  161|  4.53k|  return std::numeric_limits<T>::digits - countl_zero(x);
  162|  4.53k|}

_ZN4absl12lts_20240116mlENS0_7uint128ES1_:
  982|  19.8k|inline uint128 operator*(uint128 lhs, uint128 rhs) {
  983|  19.8k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  984|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
  985|       |  // can be used for uint128 storage.
  986|  19.8k|  return static_cast<unsigned __int128>(lhs) *
  987|  19.8k|         static_cast<unsigned __int128>(rhs);
  988|       |#elif defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
  989|       |  uint64_t carry;
  990|       |  uint64_t low = _umul128(Uint128Low64(lhs), Uint128Low64(rhs), &carry);
  991|       |  return MakeUint128(Uint128Low64(lhs) * Uint128High64(rhs) +
  992|       |                         Uint128High64(lhs) * Uint128Low64(rhs) + carry,
  993|       |                     low);
  994|       |#else   // ABSL_HAVE_INTRINSIC128
  995|       |  uint64_t a32 = Uint128Low64(lhs) >> 32;
  996|       |  uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
  997|       |  uint64_t b32 = Uint128Low64(rhs) >> 32;
  998|       |  uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
  999|       |  uint128 result =
 1000|       |      MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
 1001|       |                      Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
 1002|       |                  a00 * b00);
 1003|       |  result += uint128(a32 * b00) << 32;
 1004|       |  result += uint128(a00 * b32) << 32;
 1005|       |  return result;
 1006|       |#endif  // ABSL_HAVE_INTRINSIC128
 1007|  19.8k|}
_ZNK4absl12lts_202401167uint128cvoEv:
  776|   238k|constexpr uint128::operator unsigned __int128() const {
  777|   238k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  778|   238k|}
_ZN4absl12lts_202401167uint128C2Eo:
  674|   109k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  675|   109k|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202401167uint128C2Em:
  665|  45.8k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZNK4absl12lts_202401167uint128cvmEv:
  759|  14.8k|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  760|  14.8k|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  761|  14.8k|}
_ZN4absl12lts_20240116rsENS0_7uint128Ei:
  922|  23.1k|constexpr uint128 operator>>(uint128 lhs, int amount) {
  923|  23.1k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  924|  23.1k|  return static_cast<unsigned __int128>(lhs) >> amount;
  925|       |#else
  926|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  927|       |  // special-casing.
  928|       |  return amount >= 64  ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
  929|       |         : amount == 0 ? lhs
  930|       |                       : MakeUint128(Uint128High64(lhs) >> amount,
  931|       |                                     (Uint128Low64(lhs) >> amount) |
  932|       |                                         (Uint128High64(lhs) << (64 - amount)));
  933|       |#endif
  934|  23.1k|}
_ZN4absl12lts_202401167uint128rSEi:
  613|  23.1k|inline uint128& uint128::operator>>=(int amount) {
  614|  23.1k|  *this = *this >> amount;
  615|  23.1k|  return *this;
  616|  23.1k|}
_ZN4absl12lts_202401167uint128pLES1_:
  618|  2.61k|inline uint128& uint128::operator+=(uint128 other) {
  619|  2.61k|  *this = *this + other;
  620|  2.61k|  return *this;
  621|  2.61k|}
_ZN4absl12lts_202401167uint128mLES1_:
  628|  11.0k|inline uint128& uint128::operator*=(uint128 other) {
  629|  11.0k|  *this = *this * other;
  630|  11.0k|  return *this;
  631|  11.0k|}
_ZN4absl12lts_2024011612Uint128Low64ENS0_7uint128E:
  643|  11.2k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2024011613Uint128High64ENS0_7uint128E:
  645|  47.7k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZN4absl12lts_20240116eqENS0_7uint128ES1_:
  798|  22.0k|constexpr bool operator==(uint128 lhs, uint128 rhs) {
  799|  22.0k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  800|  22.0k|  return static_cast<unsigned __int128>(lhs) ==
  801|  22.0k|         static_cast<unsigned __int128>(rhs);
  802|       |#else
  803|       |  return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
  804|       |          Uint128High64(lhs) == Uint128High64(rhs));
  805|       |#endif
  806|  22.0k|}
_ZN4absl12lts_20240116ltENS0_7uint128ES1_:
  810|  12.5k|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  811|  12.5k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  812|  12.5k|  return static_cast<unsigned __int128>(lhs) <
  813|  12.5k|         static_cast<unsigned __int128>(rhs);
  814|       |#else
  815|       |  return (Uint128High64(lhs) == Uint128High64(rhs))
  816|       |             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
  817|       |             : (Uint128High64(lhs) < Uint128High64(rhs));
  818|       |#endif
  819|  12.5k|}
_ZN4absl12lts_20240116gtENS0_7uint128ES1_:
  821|  12.5k|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20240116anENS0_7uint128ES1_:
  871|  13.7k|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  872|  13.7k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  873|  13.7k|  return static_cast<unsigned __int128>(lhs) &
  874|  13.7k|         static_cast<unsigned __int128>(rhs);
  875|       |#else
  876|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  877|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  878|       |#endif
  879|  13.7k|}
_ZN4absl12lts_20240116lsENS0_7uint128Ei:
  908|  27.3k|constexpr uint128 operator<<(uint128 lhs, int amount) {
  909|  27.3k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  910|  27.3k|  return static_cast<unsigned __int128>(lhs) << amount;
  911|       |#else
  912|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  913|       |  // special-casing.
  914|       |  return amount >= 64  ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
  915|       |         : amount == 0 ? lhs
  916|       |                       : MakeUint128((Uint128High64(lhs) << amount) |
  917|       |                                         (Uint128Low64(lhs) >> (64 - amount)),
  918|       |                                     Uint128Low64(lhs) << amount);
  919|       |#endif
  920|  27.3k|}
_ZN4absl12lts_20240116plENS0_7uint128ES1_:
  947|  3.79k|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
  948|  3.79k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  949|  3.79k|  return static_cast<unsigned __int128>(lhs) +
  950|  3.79k|         static_cast<unsigned __int128>(rhs);
  951|       |#else
  952|       |  return int128_internal::AddResult(
  953|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
  954|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
  955|       |      lhs);
  956|       |#endif
  957|  3.79k|}
_ZN4absl12lts_20240116miENS0_7uint128ES1_:
  970|  21.9k|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
  971|  21.9k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  972|  21.9k|  return static_cast<unsigned __int128>(lhs) -
  973|  21.9k|         static_cast<unsigned __int128>(rhs);
  974|       |#else
  975|       |  return int128_internal::SubstructResult(
  976|       |      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
  977|       |                  Uint128Low64(lhs) - Uint128Low64(rhs)),
  978|       |      lhs, rhs);
  979|       |#endif
  980|  21.9k|}
_ZN4absl12lts_202401167uint128ppEv:
 1035|    590|inline uint128& uint128::operator++() {
 1036|    590|  *this += 1;
 1037|    590|  return *this;
 1038|    590|}
_ZN4absl12lts_202401167uint128C2Ei:
  654|  51.3k|    : lo_{static_cast<uint64_t>(v)},
  655|  51.3k|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (655:11): [True: 0, False: 51.3k]
  ------------------

_ZN4absl12lts_2024011616numeric_internal18CountLeadingZeroesImEEiT_:
  234|  21.8k|CountLeadingZeroes(T x) {
  235|  21.8k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  236|  21.8k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  237|  21.8k|                "T must have a power-of-2 size");
  238|  21.8k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  239|  21.8k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (239:10): [Folded, False: 21.8k]
  ------------------
  240|  21.8k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  241|      0|                   (std::numeric_limits<uint16_t>::digits -
  242|      0|                    std::numeric_limits<T>::digits)
  243|  21.8k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (243:17): [Folded, False: 21.8k]
  ------------------
  244|  21.8k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  245|      0|                          (std::numeric_limits<uint32_t>::digits -
  246|      0|                           std::numeric_limits<T>::digits)
  247|  21.8k|                    : CountLeadingZeroes64(x));
  248|  21.8k|}
_ZN4absl12lts_2024011616numeric_internal20CountLeadingZeroes64Em:
  180|  21.8k|CountLeadingZeroes64(uint64_t x) {
  181|  21.8k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  182|       |  // Use __builtin_clzll, which uses the following instructions:
  183|       |  //  x86: bsr, lzcnt
  184|       |  //  ARM64: clz
  185|       |  //  PPC: cntlzd
  186|  21.8k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  187|  21.8k|                "__builtin_clzll does not take 64-bit arg");
  188|       |
  189|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  190|  21.8k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (190:10): [True: 0, False: 21.8k]
  ------------------
  191|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  192|       |    (defined(_M_X64) || defined(_M_ARM64))
  193|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  194|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  195|       |  if (_BitScanReverse64(&result, x)) {
  196|       |    return 63 - result;
  197|       |  }
  198|       |  return 64;
  199|       |#elif defined(_MSC_VER) && !defined(__clang__)
  200|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  201|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  202|       |  if ((x >> 32) &&
  203|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  204|       |    return 31 - result;
  205|       |  }
  206|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  207|       |    return 63 - result;
  208|       |  }
  209|       |  return 64;
  210|       |#else
  211|       |  int zeroes = 60;
  212|       |  if (x >> 32) {
  213|       |    zeroes -= 32;
  214|       |    x >>= 32;
  215|       |  }
  216|       |  if (x >> 16) {
  217|       |    zeroes -= 16;
  218|       |    x >>= 16;
  219|       |  }
  220|       |  if (x >> 8) {
  221|       |    zeroes -= 8;
  222|       |    x >>= 8;
  223|       |  }
  224|       |  if (x >> 4) {
  225|       |    zeroes -= 4;
  226|       |    x >>= 4;
  227|       |  }
  228|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  229|       |#endif
  230|  21.8k|}
_ZN4absl12lts_2024011616numeric_internal11RotateRightImEET_S3_i:
   75|     10|    T x, int s) noexcept {
   76|     10|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
   77|     10|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
   78|     10|                "T must have a power-of-2 size");
   79|       |
   80|     10|  return static_cast<T>(x >> (s & (std::numeric_limits<T>::digits - 1))) |
   81|     10|         static_cast<T>(x << ((-s) & (std::numeric_limits<T>::digits - 1)));
   82|     10|}
_ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesItEEiT_:
  317|     27|CountTrailingZeroes(T x) noexcept {
  318|     27|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|     27|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|     27|                "T must have a power-of-2 size");
  321|     27|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|     27|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 27]
  ------------------
  323|     27|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [True: 27, Folded]
  ------------------
  324|     27|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|     27|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (325:27): [True: 0, Folded]
  ------------------
  326|      0|                              ? CountTrailingZeroesNonzero32(
  327|      0|                                    static_cast<uint32_t>(x))
  328|      0|                              : CountTrailingZeroesNonzero64(x)));
  329|     27|}
_ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero16Et:
  305|     27|CountTrailingZeroesNonzero16(uint16_t x) {
  306|     27|#if ABSL_HAVE_BUILTIN(__builtin_ctzs)
  307|     27|  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
  308|     27|                "__builtin_ctzs does not take 16-bit arg");
  309|     27|  return __builtin_ctzs(x);
  310|       |#else
  311|       |  return CountTrailingZeroesNonzero32(x);
  312|       |#endif
  313|     27|}
_ZN4absl12lts_2024011616numeric_internal19CountTrailingZeroesIjEEiT_:
  317|      4|CountTrailingZeroes(T x) noexcept {
  318|      4|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  319|      4|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  320|      4|                "T must have a power-of-2 size");
  321|      4|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  322|      4|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (322:10): [True: 0, False: 4]
  ------------------
  323|      4|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (323:20): [Folded, False: 4]
  ------------------
  324|      4|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  325|      4|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (325:27): [True: 4, Folded]
  ------------------
  326|      4|                              ? CountTrailingZeroesNonzero32(
  327|      4|                                    static_cast<uint32_t>(x))
  328|      4|                              : CountTrailingZeroesNonzero64(x)));
  329|      4|}
_ZN4absl12lts_2024011616numeric_internal28CountTrailingZeroesNonzero32Ej:
  251|      4|CountTrailingZeroesNonzero32(uint32_t x) {
  252|      4|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
  253|      4|  static_assert(sizeof(unsigned int) == sizeof(x),
  254|      4|                "__builtin_ctz does not take 32-bit arg");
  255|      4|  return __builtin_ctz(x);
  256|       |#elif defined(_MSC_VER) && !defined(__clang__)
  257|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  258|       |  _BitScanForward(&result, x);
  259|       |  return result;
  260|       |#else
  261|       |  int c = 31;
  262|       |  x &= ~x + 1;
  263|       |  if (x & 0x0000FFFF) c -= 16;
  264|       |  if (x & 0x00FF00FF) c -= 8;
  265|       |  if (x & 0x0F0F0F0F) c -= 4;
  266|       |  if (x & 0x33333333) c -= 2;
  267|       |  if (x & 0x55555555) c -= 1;
  268|       |  return c;
  269|       |#endif
  270|      4|}

_ZN4absl12lts_2024011615random_internal24InitDiscreteDistributionEPNSt3__16vectorIdNS2_9allocatorIdEEEE:
   24|      2|    std::vector<double>* probabilities) {
   25|       |  // The empty-case should already be handled by the constructor.
   26|      2|  assert(probabilities);
   27|      2|  assert(!probabilities->empty());
   28|       |
   29|       |  // Step 1. Normalize the input probabilities to 1.0.
   30|      2|  double sum = std::accumulate(std::begin(*probabilities),
   31|      2|                               std::end(*probabilities), 0.0);
   32|      2|  if (std::fabs(sum - 1.0) > 1e-6) {
  ------------------
  |  Branch (32:7): [True: 2, False: 0]
  ------------------
   33|       |    // Scale `probabilities` only when the sum is too far from 1.0.  Scaling
   34|       |    // unconditionally will alter the probabilities slightly.
   35|      2|    for (double& item : *probabilities) {
  ------------------
  |  Branch (35:23): [True: 2, False: 2]
  ------------------
   36|      2|      item = item / sum;
   37|      2|    }
   38|      2|  }
   39|       |
   40|       |  // Step 2. At this point `probabilities` is set to the conditional
   41|       |  // probabilities of each element which sum to 1.0, to within reasonable error.
   42|       |  // These values are used to construct the proportional probability tables for
   43|       |  // the selection phases of Walker's Aliasing algorithm.
   44|       |  //
   45|       |  // To construct the table, pick an element which is under-full (i.e., an
   46|       |  // element for which `(*probabilities)[i] < 1.0/n`), and pair it with an
   47|       |  // element which is over-full (i.e., an element for which
   48|       |  // `(*probabilities)[i] > 1.0/n`). The smaller value can always be retired.
   49|       |  // The larger may still be greater than 1.0/n, or may now be less than 1.0/n,
   50|       |  // and put back onto the appropriate collection.
   51|      2|  const size_t n = probabilities->size();
   52|      2|  std::vector<std::pair<double, size_t>> q;
   53|      2|  q.reserve(n);
   54|       |
   55|      2|  std::vector<size_t> over;
   56|      2|  std::vector<size_t> under;
   57|      2|  size_t idx = 0;
   58|      2|  for (const double item : *probabilities) {
  ------------------
  |  Branch (58:26): [True: 2, False: 2]
  ------------------
   59|      2|    assert(item >= 0);
   60|      2|    const double v = item * n;
   61|      2|    q.emplace_back(v, 0);
   62|      2|    if (v < 1.0) {
  ------------------
  |  Branch (62:9): [True: 0, False: 2]
  ------------------
   63|      0|      under.push_back(idx++);
   64|      2|    } else {
   65|      2|      over.push_back(idx++);
   66|      2|    }
   67|      2|  }
   68|      2|  while (!over.empty() && !under.empty()) {
  ------------------
  |  Branch (68:10): [True: 2, False: 0]
  |  Branch (68:27): [True: 0, False: 2]
  ------------------
   69|      0|    auto lo = under.back();
   70|      0|    under.pop_back();
   71|      0|    auto hi = over.back();
   72|      0|    over.pop_back();
   73|       |
   74|      0|    q[lo].second = hi;
   75|      0|    const double r = q[hi].first - (1.0 - q[lo].first);
   76|      0|    q[hi].first = r;
   77|      0|    if (r < 1.0) {
  ------------------
  |  Branch (77:9): [True: 0, False: 0]
  ------------------
   78|      0|      under.push_back(hi);
   79|      0|    } else {
   80|      0|      over.push_back(hi);
   81|      0|    }
   82|      0|  }
   83|       |
   84|       |  // Due to rounding errors, there may be un-paired elements in either
   85|       |  // collection; these should all be values near 1.0.  For these values, set `q`
   86|       |  // to 1.0 and set the alternate to the identity.
   87|      2|  for (auto i : over) {
  ------------------
  |  Branch (87:15): [True: 2, False: 2]
  ------------------
   88|      2|    q[i] = {1.0, i};
   89|      2|  }
   90|      2|  for (auto i : under) {
  ------------------
  |  Branch (90:15): [True: 0, False: 2]
  ------------------
   91|      0|    q[i] = {1.0, i};
   92|      0|  }
   93|      2|  return q;
   94|      2|}

_ZN4absl12lts_2024011621discrete_distributionIiEC2Ev:
  111|      2|  discrete_distribution() : param_() {}
_ZN4absl12lts_2024011621discrete_distributionIiE10param_typeC2Ev:
   60|      2|    param_type() { init(); }
_ZN4absl12lts_2024011621discrete_distributionIiE10param_type4initEv:
  183|      4|void discrete_distribution<IntType>::param_type::init() {
  184|      4|  if (p_.empty()) {
  ------------------
  |  Branch (184:7): [True: 2, False: 2]
  ------------------
  185|      2|    p_.push_back(1.0);
  186|      2|    q_.emplace_back(1.0, 0);
  187|      2|  } else {
  188|       |    assert(n() <= (std::numeric_limits<IntType>::max)());
  189|      2|    q_ = random_internal::InitDiscreteDistribution(&p_);
  190|      2|  }
  191|      4|}
_ZN4absl12lts_2024011621discrete_distributionIiEC2INSt3__111__wrap_iterIPdEEEET_S8_:
  117|      2|      : param_(begin, end) {}
_ZN4absl12lts_2024011621discrete_distributionIiE10param_typeC2INSt3__111__wrap_iterIPdEEEET_S9_:
   64|      2|        : p_(begin, end) {
   65|      2|      init();
   66|      2|    }

_ZN4absl12lts_202401167UniformIjRNS0_15random_internal17NonsecureURBGBaseINS2_13randen_engineImEENS2_17RandenPoolSeedSeqEEEEENSt3__19enable_ifIXntsr3std9is_signedIT_EE5valueESB_E4typeEOT0_:
  212|     16|Uniform(URBG&& urbg) {  // NOLINT(runtime/references)
  213|     16|  using gen_t = absl::decay_t<URBG>;
  214|     16|  using distribution_t = random_internal::UniformDistributionWrapper<R>;
  215|       |
  216|     16|  return random_internal::DistributionCaller<gen_t>::template Call<
  217|     16|      distribution_t>(&urbg);
  218|     16|}

_ZN4absl12lts_2024011615random_internal18DistributionCallerINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEE4CallINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeEPS7_DpOT0_:
   85|     16|  static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
   86|     16|    return Impl<DistrT, Args...>(HasInvokeMock{}, urbg,
   87|     16|                                 std::forward<Args>(args)...);
   88|     16|  }
_ZN4absl12lts_2024011615random_internal18DistributionCallerINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEE4ImplINS1_26UniformDistributionWrapperIjEEJEEENT_11result_typeENSt3__117integral_constantIbLb0EEEPS7_DpOT0_:
   59|     16|                                           Args&&... args) {
   60|     16|    DistrT dist(std::forward<Args>(args)...);
   61|     16|    return dist(*urbg);
   62|     16|  }

_ZN4absl12lts_2024011615random_internal15FastUniformBitsIjEclINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEEEjRT_:
  122|     16|FastUniformBits<UIntType>::operator()(URBG& g) {  // NOLINT(runtime/references)
  123|       |  // kRangeMask is the mask used when sampling variates from the URBG when the
  124|       |  // width of the URBG range is not a power of 2.
  125|       |  // Y = (2 ^ kRange) - 1
  126|     16|  static_assert((URBG::max)() > (URBG::min)(),
  127|     16|                "URBG::max and URBG::min may not be equal.");
  128|       |
  129|     16|  using tag = absl::conditional_t<IsPowerOfTwoOrZero(RangeSize<URBG>()),
  130|     16|                                  SimplifiedLoopTag, RejectionLoopTag>;
  131|     16|  return Generate(g, tag{});
  132|     16|}
_ZN4absl12lts_2024011615random_internal15FastUniformBitsIjE8GenerateINS1_17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEEEEjRT_NS1_17SimplifiedLoopTagE:
  138|     16|                                    SimplifiedLoopTag) {
  139|       |  // The simplified version of FastUniformBits works only on URBGs that have
  140|       |  // a range that is a power of 2. In this case we simply loop and shift without
  141|       |  // attempting to balance the bits across calls.
  142|     16|  static_assert(IsPowerOfTwoOrZero(RangeSize<URBG>()),
  143|     16|                "incorrect Generate tag for URBG instance");
  144|       |
  145|     16|  static constexpr size_t kResultBits =
  146|     16|      std::numeric_limits<result_type>::digits;
  147|     16|  static constexpr size_t kUrbgBits = NumBits<URBG>();
  148|     16|  static constexpr size_t kIters =
  149|     16|      (kResultBits / kUrbgBits) + (kResultBits % kUrbgBits != 0);
  150|     16|  static constexpr size_t kShift = (kIters == 1) ? 0 : kUrbgBits;
  ------------------
  |  Branch (150:36): [True: 0, Folded]
  ------------------
  151|     16|  static constexpr auto kMin = (URBG::min)();
  152|       |
  153|     16|  result_type r = static_cast<result_type>(g() - kMin);
  154|     16|  for (size_t n = 1; n < kIters; ++n) {
  ------------------
  |  Branch (154:22): [True: 0, False: 16]
  ------------------
  155|      0|    r = static_cast<result_type>(r << kShift) +
  156|      0|        static_cast<result_type>(g() - kMin);
  157|      0|  }
  158|     16|  return r;
  159|     16|}

_ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq4sizeEv:
   67|      2|  size_t size() { return 0; }
_ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2Ev:
  101|      2|  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
_ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGEv:
  142|      2|  static URBG ConstructURBG() {
  143|      2|    Seeder seeder;
  144|      2|    return URBG(seeder);
  145|      2|  }
_ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq8generateIPjEEvT_S5_:
   73|      2|  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
   74|       |    // RandomAccessIterator must be assignable from uint32_t
   75|      2|    if (begin != end) {
  ------------------
  |  Branch (75:9): [True: 2, False: 0]
  ------------------
   76|      2|      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
   77|       |      // ContiguousTag indicates the common case of a known contiguous buffer,
   78|       |      // which allows directly filling the buffer. In C++20,
   79|       |      // std::contiguous_iterator_tag provides a mechanism for testing this
   80|       |      // capability, however until Abseil's support requirements allow us to
   81|       |      // assume C++20, limit checks to a few common cases.
   82|      2|      using TagType = absl::conditional_t<
   83|      2|          (std::is_pointer<RandomAccessIterator>::value ||
   84|      2|           std::is_same<RandomAccessIterator,
   85|      2|                        typename std::vector<U>::iterator>::value),
   86|      2|          ContiguousTag, BufferTag>;
   87|       |
   88|      2|      generate_impl(TagType{}, begin, end);
   89|      2|    }
   90|      2|  }
_ZN4absl12lts_2024011615random_internal17RandenPoolSeedSeq13generate_implIPjEEvNS2_13ContiguousTagET_S6_:
   46|      2|  void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
   47|      2|    const size_t n = static_cast<size_t>(std::distance(begin, end));
   48|      2|    auto* a = &(*begin);
   49|      2|    RandenPool<uint8_t>::Fill(
   50|      2|        absl::MakeSpan(reinterpret_cast<uint8_t*>(a), sizeof(*a) * n));
   51|      2|  }
_ZN4absl12lts_2024011615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEclEv:
  126|     16|  result_type operator()() { return urbg_(); }

_ZN4absl12lts_2024011615random_internal10RandenPoolIhE4FillENS0_4SpanIhEE:
  240|      2|void RandenPool<T>::Fill(absl::Span<result_type> data) {
  241|      2|  auto* pool = GetPoolForCurrentThread();
  242|      2|  pool->Fill(reinterpret_cast<uint8_t*>(data.data()),
  243|      2|             data.size() * sizeof(result_type));
  244|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry11MaybeRefillEv:
   69|      2|  inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
   70|      2|    if (next_ >= kState) {
  ------------------
  |  Branch (70:9): [True: 2, False: 0]
  ------------------
   71|      2|      next_ = kCapacity;
   72|      2|      impl_.Generate(state_);
   73|      2|    }
   74|      2|  }
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry4FillEPhm:
  120|      2|void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
  121|      2|  SpinLockHolder l(&mu_);
  122|      4|  while (bytes > 0) {
  ------------------
  |  Branch (122:10): [True: 2, False: 2]
  ------------------
  123|      2|    MaybeRefill();
  124|      2|    size_t remaining = (kState - next_) * sizeof(state_[0]);
  125|      2|    size_t to_copy = std::min(bytes, remaining);
  126|      2|    std::memcpy(out, &state_[next_], to_copy);
  127|      2|    out += to_copy;
  128|      2|    bytes -= to_copy;
  129|      2|    next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]);
  130|      2|  }
  131|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_123GetPoolForCurrentThreadEv:
  226|      2|RandenPoolEntry* GetPoolForCurrentThread() {
  227|      2|  absl::call_once(pool_once, InitPoolURBG);
  228|      2|  return shared_pools[GetPoolID()];
  229|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_112InitPoolURBGEv:
  209|      2|void InitPoolURBG() {
  210|      2|  static constexpr size_t kSeedSize =
  211|      2|      RandenTraits::kStateBytes / sizeof(uint32_t);
  212|       |  // Read the seed data from OS entropy once.
  213|      2|  uint32_t seed_material[kPoolSize * kSeedSize];
  214|      2|  if (!random_internal::ReadSeedMaterialFromOSEntropy(
  ------------------
  |  Branch (214:7): [True: 0, False: 2]
  ------------------
  215|      2|          absl::MakeSpan(seed_material))) {
  216|      0|    random_internal::ThrowSeedGenException();
  217|      0|  }
  218|     18|  for (size_t i = 0; i < kPoolSize; i++) {
  ------------------
  |  Branch (218:22): [True: 16, False: 2]
  ------------------
  219|     16|    shared_pools[i] = PoolAlignedAlloc();
  220|     16|    shared_pools[i]->Init(
  221|     16|        absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize));
  222|     16|  }
  223|      2|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_116PoolAlignedAllocEv:
  190|     16|RandenPoolEntry* PoolAlignedAlloc() {
  191|     16|  constexpr size_t kAlignment =
  192|     16|      ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32;
  ------------------
  |  |   77|     16|#define ABSL_CACHELINE_SIZE 64
  ------------------
                    ABSL_CACHELINE_SIZE > 32 ? ABSL_CACHELINE_SIZE : 32;
  ------------------
  |  |   77|      0|#define ABSL_CACHELINE_SIZE 64
  ------------------
  |  Branch (192:7): [True: 0, Folded]
  ------------------
  193|       |
  194|       |  // Not all the platforms that we build for have std::aligned_alloc, however
  195|       |  // since we never free these objects, we can over allocate and munge the
  196|       |  // pointers to the correct alignment.
  197|     16|  uintptr_t x = reinterpret_cast<uintptr_t>(
  198|     16|      new char[sizeof(RandenPoolEntry) + kAlignment]);
  199|     16|  auto y = x % kAlignment;
  200|     16|  void* aligned = reinterpret_cast<void*>(y == 0 ? x : (x + kAlignment - y));
  ------------------
  |  Branch (200:43): [True: 4, False: 12]
  ------------------
  201|     16|  return new (aligned) RandenPoolEntry();
  202|     16|}
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_115RandenPoolEntry4InitENS0_4SpanIKjEE:
   56|     16|  void Init(absl::Span<const uint32_t> data) {
   57|     16|    SpinLockHolder l(&mu_);  // Always uncontested.
   58|     16|    std::copy(data.begin(), data.end(), std::begin(state_));
   59|     16|    next_ = kState;
   60|     16|  }
pool_urbg.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_19GetPoolIDEv:
  150|      2|size_t GetPoolID() {
  151|      2|  static_assert(kPoolSize >= 1,
  152|      2|                "At least one urbg instance is required for PoolURBG");
  153|       |
  154|      2|  ABSL_CONST_INIT static std::atomic<uint64_t> sequence{0};
  ------------------
  |  |  745|      2|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  155|       |
  156|      2|#ifdef ABSL_HAVE_THREAD_LOCAL
  157|      2|  static thread_local size_t my_pool_id = kPoolSize;
  158|      2|  if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) {
  ------------------
  |  |  178|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 2, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 2]
  |  |  |  Branch (178:58): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  159|      2|    my_pool_id = (sequence++ % kPoolSize);
  160|      2|  }
  161|      2|  return my_pool_id;
  162|       |#else
  163|       |  static pthread_key_t tid_key = [] {
  164|       |    pthread_key_t tmp_key;
  165|       |    int err = pthread_key_create(&tmp_key, nullptr);
  166|       |    if (err) {
  167|       |      ABSL_RAW_LOG(FATAL, "pthread_key_create failed with %d", err);
  168|       |    }
  169|       |    return tmp_key;
  170|       |  }();
  171|       |
  172|       |  // Store the value in the pthread_{get/set}specific. However an uninitialized
  173|       |  // value is 0, so add +1 to distinguish from the null value.
  174|       |  uintptr_t my_pool_id =
  175|       |      reinterpret_cast<uintptr_t>(pthread_getspecific(tid_key));
  176|       |  if (ABSL_PREDICT_FALSE(my_pool_id == 0)) {
  177|       |    // No allocated ID, allocate the next value, cache it, and return.
  178|       |    my_pool_id = (sequence++ % kPoolSize) + 1;
  179|       |    int err = pthread_setspecific(tid_key, reinterpret_cast<void*>(my_pool_id));
  180|       |    if (err) {
  181|       |      ABSL_RAW_LOG(FATAL, "pthread_setspecific failed with %d", err);
  182|       |    }
  183|       |  }
  184|       |  return my_pool_id - 1;
  185|       |#endif
  186|      2|}

_ZN4absl12lts_2024011615random_internal6RandenC2Ev:
   81|     18|Randen::Randen() {
   82|     18|  auto tmp = GetRandenState();
   83|     18|  keys_ = tmp.keys;
   84|     18|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   85|     18|  has_crypto_ = tmp.has_crypto;
   86|     18|#endif
   87|     18|}
randen.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_114GetRandenStateEv:
   53|     18|RandenState GetRandenState() {
   54|     18|  static const RandenState state = []() {
   55|     18|    RandenState tmp;
   56|     18|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|     18|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
   59|     18|      tmp.has_crypto = true;
   60|     18|      tmp.keys = RandenHwAes::GetKeys();
   61|     18|    } else {
   62|     18|      tmp.has_crypto = false;
   63|     18|      tmp.keys = RandenSlow::GetKeys();
   64|     18|    }
   65|       |#elif ABSL_HAVE_ACCELERATED_AES
   66|       |    // HW AES is enabled.
   67|       |    tmp.has_crypto = true;
   68|       |    tmp.keys = RandenHwAes::GetKeys();
   69|       |#else
   70|       |    // HW AES is disabled.
   71|       |    tmp.has_crypto = false;
   72|       |    tmp.keys = RandenSlow::GetKeys();
   73|       |#endif
   74|     18|    return tmp;
   75|     18|  }();
   76|     18|  return state;
   77|     18|}
randen.cc:_ZZN4absl12lts_2024011615random_internal12_GLOBAL__N_114GetRandenStateEvENK3$_0clEv:
   54|      2|  static const RandenState state = []() {
   55|      2|    RandenState tmp;
   56|      2|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|      2|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
  ------------------
  |  Branch (58:9): [True: 2, False: 0]
  |  Branch (58:43): [True: 2, False: 0]
  ------------------
   59|      2|      tmp.has_crypto = true;
   60|      2|      tmp.keys = RandenHwAes::GetKeys();
   61|      2|    } else {
   62|      0|      tmp.has_crypto = false;
   63|      0|      tmp.keys = RandenSlow::GetKeys();
   64|      0|    }
   65|       |#elif ABSL_HAVE_ACCELERATED_AES
   66|       |    // HW AES is enabled.
   67|       |    tmp.has_crypto = true;
   68|       |    tmp.keys = RandenHwAes::GetKeys();
   69|       |#else
   70|       |    // HW AES is disabled.
   71|       |    tmp.has_crypto = false;
   72|       |    tmp.keys = RandenSlow::GetKeys();
   73|       |#endif
   74|      2|    return tmp;
   75|      2|  }();

_ZNK4absl12lts_2024011615random_internal6Randen8GenerateEPv:
   47|      4|  inline void Generate(void* state) const {
   48|      4|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   49|       |    // HW AES Dispatch.
   50|      4|    if (has_crypto_) {
  ------------------
  |  Branch (50:9): [True: 4, False: 0]
  ------------------
   51|      4|      RandenHwAes::Generate(keys_, state);
   52|      4|    } else {
   53|      0|      RandenSlow::Generate(keys_, state);
   54|      0|    }
   55|       |#elif ABSL_HAVE_ACCELERATED_AES
   56|       |    // HW AES is enabled.
   57|       |    RandenHwAes::Generate(keys_, state);
   58|       |#else
   59|       |    // HW AES is disabled.
   60|       |    RandenSlow::Generate(keys_, state);
   61|       |#endif
   62|      4|  }
_ZNK4absl12lts_2024011615random_internal6Randen6AbsorbEPKvPv:
   68|      2|  inline void Absorb(const void* seed, void* state) const {
   69|      2|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   70|       |    // HW AES Dispatch.
   71|      2|    if (has_crypto_) {
  ------------------
  |  Branch (71:9): [True: 2, False: 0]
  ------------------
   72|      2|      RandenHwAes::Absorb(seed, state);
   73|      2|    } else {
   74|      0|      RandenSlow::Absorb(seed, state);
   75|      0|    }
   76|       |#elif ABSL_HAVE_ACCELERATED_AES
   77|       |    // HW AES is enabled.
   78|       |    RandenHwAes::Absorb(seed, state);
   79|       |#else
   80|       |    // HW AES is disabled.
   81|       |    RandenSlow::Absorb(seed, state);
   82|       |#endif
   83|      2|  }

_ZN4absl12lts_2024011615random_internal22CPUSupportsRandenHwAesEv:
  135|      2|bool CPUSupportsRandenHwAes() {
  136|      2|#if defined(ABSL_INTERNAL_USE_X86_CPUID)
  137|       |  // 1. For x86: Use CPUID to detect the required AES instruction set.
  138|      2|  int regs[4];
  139|      2|  __cpuid(reinterpret_cast<int*>(regs), 1);
  140|      2|  return regs[2] & (1 << 25);  // AES
  141|       |
  142|       |#elif defined(ABSL_INTERNAL_USE_GETAUXVAL)
  143|       |  // 2. Use getauxval() to read the hardware bits and determine
  144|       |  // cpu capabilities.
  145|       |
  146|       |#define AT_HWCAP 16
  147|       |#define AT_HWCAP2 26
  148|       |#if defined(ABSL_ARCH_PPC)
  149|       |  // For Power / PPC: Expect that the cpu supports VCRYPTO
  150|       |  // See https://members.openpowerfoundation.org/document/dl/576
  151|       |  // VCRYPTO should be present in POWER8 >= 2.07.
  152|       |  // Uses Linux kernel constants from arch/powerpc/include/uapi/asm/cputable.h
  153|       |  static const uint32_t kVCRYPTO = 0x02000000;
  154|       |  const uint32_t hwcap = GetAuxval(AT_HWCAP2);
  155|       |  return (hwcap & kVCRYPTO) != 0;
  156|       |
  157|       |#elif defined(ABSL_ARCH_ARM)
  158|       |  // For ARM: Require crypto+neon
  159|       |  // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500f/CIHBIBBA.html
  160|       |  // Uses Linux kernel constants from arch/arm64/include/asm/hwcap.h
  161|       |  static const uint32_t kNEON = 1 << 12;
  162|       |  uint32_t hwcap = GetAuxval(AT_HWCAP);
  163|       |  if ((hwcap & kNEON) == 0) {
  164|       |    return false;
  165|       |  }
  166|       |
  167|       |  // And use it again to detect AES.
  168|       |  static const uint32_t kAES = 1 << 0;
  169|       |  const uint32_t hwcap2 = GetAuxval(AT_HWCAP2);
  170|       |  return (hwcap2 & kAES) != 0;
  171|       |
  172|       |#elif defined(ABSL_ARCH_AARCH64)
  173|       |  // For AARCH64: Require crypto+neon
  174|       |  // http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500f/CIHBIBBA.html
  175|       |  static const uint32_t kNEON = 1 << 1;
  176|       |  static const uint32_t kAES = 1 << 3;
  177|       |  const uint32_t hwcap = GetAuxval(AT_HWCAP);
  178|       |  return ((hwcap & kNEON) != 0) && ((hwcap & kAES) != 0);
  179|       |#endif
  180|       |
  181|       |#else  // ABSL_INTERNAL_USE_GETAUXVAL
  182|       |  // 3. By default, assume that the compiler default.
  183|       |  return ABSL_HAVE_ACCELERATED_AES ? true : false;
  184|       |
  185|       |#endif
  186|       |  // NOTE: There are some other techniques that may be worth trying:
  187|       |  //
  188|       |  // * Use an environment variable: ABSL_RANDOM_USE_HWAES
  189|       |  //
  190|       |  // * Rely on compiler-generated target-based dispatch.
  191|       |  // Using x86/gcc it might look something like this:
  192|       |  //
  193|       |  // int __attribute__((target("aes"))) HasAes() { return 1; }
  194|       |  // int __attribute__((target("default"))) HasAes() { return 0; }
  195|       |  //
  196|       |  // This does not work on all architecture/compiler combinations.
  197|       |  //
  198|       |  // * On Linux consider reading /proc/cpuinfo and/or /proc/self/auxv.
  199|       |  // These files have lines which are easy to parse; for ARM/AARCH64 it is quite
  200|       |  // easy to find the Features: line and extract aes / neon. Likewise for
  201|       |  // PPC.
  202|       |  //
  203|       |  // * Fork a process and test for SIGILL:
  204|       |  //
  205|       |  // * Many architectures have instructions to read the ISA. Unfortunately
  206|       |  //   most of those require that the code is running in ring 0 /
  207|       |  //   protected-mode.
  208|       |  //
  209|       |  //   There are several examples. e.g. Valgrind detects PPC ISA 2.07:
  210|       |  //   https://github.com/lu-zero/valgrind/blob/master/none/tests/ppc64/test_isa_2_07_part1.c
  211|       |  //
  212|       |  //   MRS <Xt>, ID_AA64ISAR0_EL1 ; Read ID_AA64ISAR0_EL1 into Xt
  213|       |  //
  214|       |  //   uint64_t val;
  215|       |  //   __asm __volatile("mrs %0, id_aa64isar0_el1" :"=&r" (val));
  216|       |  //
  217|       |  // * Use a CPUID-style heuristic database.
  218|       |  //
  219|       |  // * On Apple (__APPLE__), AES is available on Arm v8.
  220|       |  //   https://stackoverflow.com/questions/45637888/how-to-determine-armv8-features-at-runtime-on-ios
  221|      2|}
randen_detect.cc:_ZL7__cpuidPii:
   54|      2|static void __cpuid(int cpu_info[4], int info_type) {
   55|      2|  __asm__ volatile("cpuid \n\t"
   56|      2|                   : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]),
   57|      2|                     "=d"(cpu_info[3])
   58|      2|                   : "a"(info_type), "c"(0));
   59|      2|}

_ZN4absl12lts_2024011615random_internal13randen_engineImEC2IRNS1_17RandenPoolSeedSeqEvEEOT_:
   67|      2|  explicit randen_engine(SeedSequence&& seq) {
   68|      2|    seed(seq);
   69|      2|  }
_ZN4absl12lts_2024011615random_internal13randen_engineImE4seedIRNS1_17RandenPoolSeedSeqEEENSt3__19enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOS9_:
   97|      2|  seed(SeedSequence&& seq) {
   98|       |    // Zeroes the state.
   99|      2|    seed();
  100|      2|    reseed(seq);
  101|      2|  }
_ZN4absl12lts_2024011615random_internal13randen_engineImE4seedEm:
  103|      2|  void seed(result_type seed_value = 0) {
  104|      2|    next_ = kStateSizeT;
  105|       |    // Zeroes the inner state and fills the outer state with seed_value to
  106|       |    // mimic the behaviour of reseed
  107|      2|    auto* begin = state();
  108|      2|    std::fill(begin, begin + kCapacityT, 0);
  109|      2|    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
  110|      2|  }
_ZN4absl12lts_2024011615random_internal13randen_engineImE5stateEv:
  244|     20|  result_type* state() {
  245|     20|    return reinterpret_cast<result_type*>(
  246|     20|        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
  ------------------
  |  Branch (246:9): [True: 0, False: 20]
  ------------------
  247|     20|                                                         : raw_state_);
  248|     20|  }
_ZN4absl12lts_2024011615random_internal13randen_engineImE6reseedINS1_17RandenPoolSeedSeqEEEvRT_:
  116|      2|  void reseed(SeedSequence& seq) {
  117|      2|    using sequence_result_type = typename SeedSequence::result_type;
  118|      2|    static_assert(sizeof(sequence_result_type) == 4,
  119|      2|                  "SeedSequence::result_type must be 32-bit");
  120|      2|    constexpr size_t kBufferSize =
  121|      2|        Randen::kSeedBytes / sizeof(sequence_result_type);
  122|      2|    alignas(16) sequence_result_type buffer[kBufferSize];
  123|       |
  124|       |    // Randen::Absorb XORs the seed into state, which is then mixed by a call
  125|       |    // to Randen::Generate. Seeding with only the provided entropy is preferred
  126|       |    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
  127|       |    // size as a proxy for the number of entropy units that can be generated
  128|       |    // without relying on seed sequence mixing...
  129|      2|    const size_t entropy_size = seq.size();
  130|      2|    if (entropy_size < kBufferSize) {
  ------------------
  |  Branch (130:9): [True: 2, False: 0]
  ------------------
  131|       |      // ... and only request that many values, or 256-bits, when unspecified.
  132|      2|      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
  ------------------
  |  Branch (132:40): [True: 2, False: 0]
  ------------------
  133|      2|      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
  134|      2|      seq.generate(buffer, buffer + requested_entropy);
  135|       |#ifdef ABSL_IS_BIG_ENDIAN
  136|       |      // Randen expects the seed buffer to be in Little Endian; reverse it on
  137|       |      // Big Endian platforms.
  138|       |      for (sequence_result_type& e : buffer) {
  139|       |        e = absl::little_endian::FromHost(e);
  140|       |      }
  141|       |#endif
  142|       |      // The Randen paper suggests preferentially initializing even-numbered
  143|       |      // 128-bit vectors of the randen state (there are 16 such vectors).
  144|       |      // The seed data is merged into the state offset by 128-bits, which
  145|       |      // implies preferring seed bytes [16..31, ..., 208..223]. Since the
  146|       |      // buffer is 32-bit values, we swap the corresponding buffer positions in
  147|       |      // 128-bit chunks.
  148|      2|      size_t dst = kBufferSize;
  149|     16|      while (dst > 7) {
  ------------------
  |  Branch (149:14): [True: 14, False: 2]
  ------------------
  150|       |        // leave the odd bucket as-is.
  151|     14|        dst -= 4;
  152|     14|        size_t src = dst >> 1;
  153|       |        // swap 128-bits into the even bucket
  154|     14|        std::swap(buffer[--dst], buffer[--src]);
  155|     14|        std::swap(buffer[--dst], buffer[--src]);
  156|     14|        std::swap(buffer[--dst], buffer[--src]);
  157|     14|        std::swap(buffer[--dst], buffer[--src]);
  158|     14|      }
  159|      2|    } else {
  160|      0|      seq.generate(buffer, buffer + kBufferSize);
  161|      0|    }
  162|      2|    impl_.Absorb(buffer, state());
  163|       |
  164|       |    // Generate will be called when operator() is called
  165|      2|    next_ = kStateSizeT;
  166|      2|  }
_ZN4absl12lts_2024011615random_internal13randen_engineImEclEv:
   84|     16|  result_type operator()() {
   85|       |    // Refill the buffer if needed (unlikely).
   86|     16|    auto* begin = state();
   87|     16|    if (next_ >= kStateSizeT) {
  ------------------
  |  Branch (87:9): [True: 2, False: 14]
  ------------------
   88|      2|      next_ = kCapacityT;
   89|      2|      impl_.Generate(begin);
   90|      2|    }
   91|     16|    return little_endian::ToHost(begin[next_++]);
   92|     16|  }

_ZN4absl12lts_2024011615random_internal28HasRandenHwAesImplementationEv:
  408|      2|bool HasRandenHwAesImplementation() { return true; }
_ZN4absl12lts_2024011615random_internal11RandenHwAes7GetKeysEv:
  410|      2|const void* ABSL_TARGET_CRYPTO RandenHwAes::GetKeys() {
  411|       |  // Round keys for one AES per Feistel round and branch.
  412|       |  // The canonical implementation uses first digits of Pi.
  413|       |#if defined(ABSL_ARCH_PPC)
  414|       |  return kRandenRoundKeysBE;
  415|       |#else
  416|      2|  return kRandenRoundKeys;
  417|      2|#endif
  418|      2|}
_ZN4absl12lts_2024011615random_internal11RandenHwAes6AbsorbEPKvPv:
  422|      2|                                            void* state_void) {
  423|      2|  static_assert(RandenTraits::kCapacityBytes / sizeof(Vector128) == 1,
  424|      2|                "Unexpected Randen kCapacityBlocks");
  425|      2|  static_assert(RandenTraits::kStateBytes / sizeof(Vector128) == 16,
  426|      2|                "Unexpected Randen kStateBlocks");
  427|       |
  428|      2|  auto* state = reinterpret_cast<absl::uint128 * ABSL_RANDOM_INTERNAL_RESTRICT>(
  429|      2|      state_void);
  430|      2|  const auto* seed =
  431|      2|      reinterpret_cast<const absl::uint128 * ABSL_RANDOM_INTERNAL_RESTRICT>(
  432|      2|          seed_void);
  433|       |
  434|      2|  Vector128 b1 = Vector128Load(state + 1);
  435|      2|  b1 ^= Vector128Load(seed + 0);
  436|      2|  Vector128Store(b1, state + 1);
  437|       |
  438|      2|  Vector128 b2 = Vector128Load(state + 2);
  439|      2|  b2 ^= Vector128Load(seed + 1);
  440|      2|  Vector128Store(b2, state + 2);
  441|       |
  442|      2|  Vector128 b3 = Vector128Load(state + 3);
  443|      2|  b3 ^= Vector128Load(seed + 2);
  444|      2|  Vector128Store(b3, state + 3);
  445|       |
  446|      2|  Vector128 b4 = Vector128Load(state + 4);
  447|      2|  b4 ^= Vector128Load(seed + 3);
  448|      2|  Vector128Store(b4, state + 4);
  449|       |
  450|      2|  Vector128 b5 = Vector128Load(state + 5);
  451|      2|  b5 ^= Vector128Load(seed + 4);
  452|      2|  Vector128Store(b5, state + 5);
  453|       |
  454|      2|  Vector128 b6 = Vector128Load(state + 6);
  455|      2|  b6 ^= Vector128Load(seed + 5);
  456|      2|  Vector128Store(b6, state + 6);
  457|       |
  458|      2|  Vector128 b7 = Vector128Load(state + 7);
  459|      2|  b7 ^= Vector128Load(seed + 6);
  460|      2|  Vector128Store(b7, state + 7);
  461|       |
  462|      2|  Vector128 b8 = Vector128Load(state + 8);
  463|      2|  b8 ^= Vector128Load(seed + 7);
  464|      2|  Vector128Store(b8, state + 8);
  465|       |
  466|      2|  Vector128 b9 = Vector128Load(state + 9);
  467|      2|  b9 ^= Vector128Load(seed + 8);
  468|      2|  Vector128Store(b9, state + 9);
  469|       |
  470|      2|  Vector128 b10 = Vector128Load(state + 10);
  471|      2|  b10 ^= Vector128Load(seed + 9);
  472|      2|  Vector128Store(b10, state + 10);
  473|       |
  474|      2|  Vector128 b11 = Vector128Load(state + 11);
  475|      2|  b11 ^= Vector128Load(seed + 10);
  476|      2|  Vector128Store(b11, state + 11);
  477|       |
  478|      2|  Vector128 b12 = Vector128Load(state + 12);
  479|      2|  b12 ^= Vector128Load(seed + 11);
  480|      2|  Vector128Store(b12, state + 12);
  481|       |
  482|      2|  Vector128 b13 = Vector128Load(state + 13);
  483|      2|  b13 ^= Vector128Load(seed + 12);
  484|      2|  Vector128Store(b13, state + 13);
  485|       |
  486|      2|  Vector128 b14 = Vector128Load(state + 14);
  487|      2|  b14 ^= Vector128Load(seed + 13);
  488|      2|  Vector128Store(b14, state + 14);
  489|       |
  490|      2|  Vector128 b15 = Vector128Load(state + 15);
  491|      2|  b15 ^= Vector128Load(seed + 14);
  492|      2|  Vector128Store(b15, state + 15);
  493|      2|}
_ZN4absl12lts_2024011615random_internal11RandenHwAes8GenerateEPKvPv:
  497|      4|                                              void* state_void) {
  498|      4|  static_assert(RandenTraits::kCapacityBytes == sizeof(Vector128),
  499|      4|                "Capacity mismatch");
  500|       |
  501|      4|  auto* state = reinterpret_cast<absl::uint128*>(state_void);
  502|      4|  const auto* keys = reinterpret_cast<const absl::uint128*>(keys_void);
  503|       |
  504|      4|  const Vector128 prev_inner = Vector128Load(state);
  505|       |
  506|      4|  SwapEndian(state);
  507|       |
  508|      4|  Permute(state, keys);
  509|       |
  510|      4|  SwapEndian(state);
  511|       |
  512|       |  // Ensure backtracking resistance.
  513|      4|  Vector128 inner = Vector128Load(state);
  514|      4|  inner ^= prev_inner;
  515|      4|  Vector128Store(inner, state);
  516|      4|}
randen_hwaes.cc:_ZN12_GLOBAL__N_113Vector128LoadEPKv:
  236|  2.78k|inline ABSL_TARGET_CRYPTO Vector128 Vector128Load(const void* from) {
  237|  2.78k|  return Vector128(_mm_load_si128(reinterpret_cast<const __m128i*>(from)));
  238|  2.78k|}
randen_hwaes.cc:_ZN12_GLOBAL__N_19Vector128C2ERKDv2_x:
  223|  3.87k|  inline explicit Vector128(const __m128i& v) : data_(v) {}
randen_hwaes.cc:_ZN12_GLOBAL__N_19Vector128eOERKS0_:
  227|     34|  inline Vector128& operator^=(const Vector128& other) {
  228|     34|    data_ = _mm_xor_si128(data_, other.data());
  229|     34|    return *this;
  230|     34|  }
randen_hwaes.cc:_ZNK12_GLOBAL__N_19Vector1284dataEv:
  225|  3.87k|  inline __m128i data() const { return data_; }
randen_hwaes.cc:_ZN12_GLOBAL__N_114Vector128StoreERKNS_9Vector128EPv:
  240|  1.66k|inline ABSL_TARGET_CRYPTO void Vector128Store(const Vector128& v, void* to) {
  241|  1.66k|  _mm_store_si128(reinterpret_cast<__m128i*>(to), v.data());
  242|  1.66k|}
randen_hwaes.cc:_ZN12_GLOBAL__N_110SwapEndianEPv:
  254|      8|inline ABSL_TARGET_CRYPTO void SwapEndian(void*) {}
randen_hwaes.cc:_ZN12_GLOBAL__N_17PermuteEPN4absl12lts_202401167uint128EPKS2_:
  391|      4|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  392|       |  // (Successfully unrolled; the first iteration jumps into the second half)
  393|      4|#ifdef __clang__
  394|      4|#pragma clang loop unroll_count(2)
  395|      4|#endif
  396|     72|  for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) {
  ------------------
  |  Branch (396:26): [True: 68, False: 4]
  ------------------
  397|     68|    keys = FeistelRound(state, keys);
  398|     68|    BlockShuffle(state);
  399|     68|  }
  400|      4|}
randen_hwaes.cc:_ZN12_GLOBAL__N_112FeistelRoundEPN4absl12lts_202401167uint128EPKS2_:
  329|     68|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  330|     68|  static_assert(RandenTraits::kFeistelBlocks == 16,
  331|     68|                "Expecting 16 FeistelBlocks.");
  332|       |
  333|       |  // MSVC does a horrible job at unrolling loops.
  334|       |  // So we unroll the loop by hand to improve the performance.
  335|     68|  const Vector128 s0 = Vector128Load(state + 0);
  336|     68|  const Vector128 s1 = Vector128Load(state + 1);
  337|     68|  const Vector128 s2 = Vector128Load(state + 2);
  338|     68|  const Vector128 s3 = Vector128Load(state + 3);
  339|     68|  const Vector128 s4 = Vector128Load(state + 4);
  340|     68|  const Vector128 s5 = Vector128Load(state + 5);
  341|     68|  const Vector128 s6 = Vector128Load(state + 6);
  342|     68|  const Vector128 s7 = Vector128Load(state + 7);
  343|     68|  const Vector128 s8 = Vector128Load(state + 8);
  344|     68|  const Vector128 s9 = Vector128Load(state + 9);
  345|     68|  const Vector128 s10 = Vector128Load(state + 10);
  346|     68|  const Vector128 s11 = Vector128Load(state + 11);
  347|     68|  const Vector128 s12 = Vector128Load(state + 12);
  348|     68|  const Vector128 s13 = Vector128Load(state + 13);
  349|     68|  const Vector128 s14 = Vector128Load(state + 14);
  350|     68|  const Vector128 s15 = Vector128Load(state + 15);
  351|       |
  352|       |  // Encode even blocks with keys.
  353|     68|  const Vector128 e0 = AesRound(s0, Vector128Load(keys + 0));
  354|     68|  const Vector128 e2 = AesRound(s2, Vector128Load(keys + 1));
  355|     68|  const Vector128 e4 = AesRound(s4, Vector128Load(keys + 2));
  356|     68|  const Vector128 e6 = AesRound(s6, Vector128Load(keys + 3));
  357|     68|  const Vector128 e8 = AesRound(s8, Vector128Load(keys + 4));
  358|     68|  const Vector128 e10 = AesRound(s10, Vector128Load(keys + 5));
  359|     68|  const Vector128 e12 = AesRound(s12, Vector128Load(keys + 6));
  360|     68|  const Vector128 e14 = AesRound(s14, Vector128Load(keys + 7));
  361|       |
  362|       |  // Encode odd blocks with even output from above.
  363|     68|  const Vector128 o1 = AesRound(e0, s1);
  364|     68|  const Vector128 o3 = AesRound(e2, s3);
  365|     68|  const Vector128 o5 = AesRound(e4, s5);
  366|     68|  const Vector128 o7 = AesRound(e6, s7);
  367|     68|  const Vector128 o9 = AesRound(e8, s9);
  368|     68|  const Vector128 o11 = AesRound(e10, s11);
  369|     68|  const Vector128 o13 = AesRound(e12, s13);
  370|     68|  const Vector128 o15 = AesRound(e14, s15);
  371|       |
  372|       |  // Store odd blocks. (These will be shuffled later).
  373|     68|  Vector128Store(o1, state + 1);
  374|     68|  Vector128Store(o3, state + 3);
  375|     68|  Vector128Store(o5, state + 5);
  376|     68|  Vector128Store(o7, state + 7);
  377|     68|  Vector128Store(o9, state + 9);
  378|     68|  Vector128Store(o11, state + 11);
  379|     68|  Vector128Store(o13, state + 13);
  380|     68|  Vector128Store(o15, state + 15);
  381|       |
  382|     68|  return keys + 8;
  383|     68|}
randen_hwaes.cc:_ZN12_GLOBAL__N_18AesRoundERKNS_9Vector128ES2_:
  247|  1.08k|                                             const Vector128& round_key) {
  248|       |  // It is important to always use the full round function - omitting the
  249|       |  // final MixColumns reduces security [https://eprint.iacr.org/2010/041.pdf]
  250|       |  // and does not help because we never decrypt.
  251|  1.08k|  return Vector128(_mm_aesenc_si128(state.data(), round_key.data()));
  252|  1.08k|}
randen_hwaes.cc:_ZN12_GLOBAL__N_112BlockShuffleEPN4absl12lts_202401167uint128E:
  280|     68|inline ABSL_TARGET_CRYPTO void BlockShuffle(absl::uint128* state) {
  281|     68|  static_assert(RandenTraits::kFeistelBlocks == 16,
  282|     68|                "Expecting 16 FeistelBlocks.");
  283|       |
  284|     68|  constexpr size_t shuffle[RandenTraits::kFeistelBlocks] = {
  285|     68|      7, 2, 13, 4, 11, 8, 3, 6, 15, 0, 9, 10, 1, 14, 5, 12};
  286|       |
  287|     68|  const Vector128 v0 = Vector128Load(state + shuffle[0]);
  288|     68|  const Vector128 v1 = Vector128Load(state + shuffle[1]);
  289|     68|  const Vector128 v2 = Vector128Load(state + shuffle[2]);
  290|     68|  const Vector128 v3 = Vector128Load(state + shuffle[3]);
  291|     68|  const Vector128 v4 = Vector128Load(state + shuffle[4]);
  292|     68|  const Vector128 v5 = Vector128Load(state + shuffle[5]);
  293|     68|  const Vector128 v6 = Vector128Load(state + shuffle[6]);
  294|     68|  const Vector128 v7 = Vector128Load(state + shuffle[7]);
  295|     68|  const Vector128 w0 = Vector128Load(state + shuffle[8]);
  296|     68|  const Vector128 w1 = Vector128Load(state + shuffle[9]);
  297|     68|  const Vector128 w2 = Vector128Load(state + shuffle[10]);
  298|     68|  const Vector128 w3 = Vector128Load(state + shuffle[11]);
  299|     68|  const Vector128 w4 = Vector128Load(state + shuffle[12]);
  300|     68|  const Vector128 w5 = Vector128Load(state + shuffle[13]);
  301|     68|  const Vector128 w6 = Vector128Load(state + shuffle[14]);
  302|     68|  const Vector128 w7 = Vector128Load(state + shuffle[15]);
  303|       |
  304|     68|  Vector128Store(v0, state + 0);
  305|     68|  Vector128Store(v1, state + 1);
  306|     68|  Vector128Store(v2, state + 2);
  307|     68|  Vector128Store(v3, state + 3);
  308|     68|  Vector128Store(v4, state + 4);
  309|     68|  Vector128Store(v5, state + 5);
  310|     68|  Vector128Store(v6, state + 6);
  311|     68|  Vector128Store(v7, state + 7);
  312|     68|  Vector128Store(w0, state + 8);
  313|     68|  Vector128Store(w1, state + 9);
  314|     68|  Vector128Store(w2, state + 10);
  315|     68|  Vector128Store(w3, state + 11);
  316|     68|  Vector128Store(w4, state + 12);
  317|     68|  Vector128Store(w5, state + 13);
  318|     68|  Vector128Store(w6, state + 14);
  319|     68|  Vector128Store(w7, state + 15);
  320|     68|}

_ZN4absl12lts_2024011615random_internal29ReadSeedMaterialFromOSEntropyENS0_4SpanIjEE:
  205|      2|bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values) {
  206|      2|  assert(values.data() != nullptr);
  207|      2|  if (values.data() == nullptr) {
  ------------------
  |  Branch (207:7): [True: 0, False: 2]
  ------------------
  208|      0|    return false;
  209|      0|  }
  210|      2|  if (values.empty()) {
  ------------------
  |  Branch (210:7): [True: 0, False: 2]
  ------------------
  211|      0|    return true;
  212|      0|  }
  213|      2|  return ReadSeedMaterialFromOSEntropyImpl(values);
  214|      2|}
seed_material.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_133ReadSeedMaterialFromOSEntropyImplENS0_4SpanIjEE:
  190|      2|bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
  191|      2|#if defined(ABSL_RANDOM_USE_GET_ENTROPY)
  192|      2|  if (ReadSeedMaterialFromGetEntropy(values)) {
  ------------------
  |  Branch (192:7): [True: 2, False: 0]
  ------------------
  193|      2|    return true;
  194|      2|  }
  195|      0|#endif
  196|       |  // Libc may support getentropy, but the kernel may not, so we still have
  197|       |  // to fallback to ReadSeedMaterialFromDevURandom().
  198|      0|  return ReadSeedMaterialFromDevURandom(values);
  199|      2|}
seed_material.cc:_ZN4absl12lts_2024011615random_internal12_GLOBAL__N_130ReadSeedMaterialFromGetEntropyENS0_4SpanIjEE:
  142|      2|bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) {
  143|      2|  auto buffer = reinterpret_cast<uint8_t*>(values.data());
  144|      2|  size_t buffer_size = sizeof(uint32_t) * values.size();
  145|     18|  while (buffer_size > 0) {
  ------------------
  |  Branch (145:10): [True: 16, False: 2]
  ------------------
  146|       |    // getentropy() has a maximum permitted length of 256.
  147|     16|    size_t to_read = std::min<size_t>(buffer_size, 256);
  148|     16|    int result = getentropy(buffer, to_read);
  149|     16|    if (result < 0) {
  ------------------
  |  Branch (149:9): [True: 0, False: 16]
  ------------------
  150|      0|      return false;
  151|      0|    }
  152|       |    // https://github.com/google/sanitizers/issues/1173
  153|       |    // MemorySanitizer can't see through getentropy().
  154|     16|    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read);
  155|     16|    buffer += to_read;
  156|     16|    buffer_size -= to_read;
  157|     16|  }
  158|      2|  return true;
  159|      2|}

_ZN4absl12lts_2024011615random_internal26UniformDistributionWrapperIjEC2Ev:
  236|     16|      : UniformDistribution<NumType>(std::numeric_limits<NumType>::lowest(),
  237|     16|                                     (std::numeric_limits<NumType>::max)()) {}

_ZNK4absl12lts_2024011624uniform_int_distributionIjE5paramEv:
  134|     16|  param_type param() const { return param_; }
_ZNK4absl12lts_2024011624uniform_int_distributionIjE10param_type1aEv:
   80|     16|    result_type a() const { return lo_; }
_ZNK4absl12lts_2024011624uniform_int_distributionIjE10param_type5rangeEv:
   95|     16|    unsigned_type range() const { return range_; }
_ZN4absl12lts_2024011624uniform_int_distributionIjEC2Ejj:
  110|     16|      : param_(lo, hi) {}
_ZN4absl12lts_2024011624uniform_int_distributionIjE10param_typeC2Ejj:
   73|     16|        : lo_(lo),
   74|     16|          range_(static_cast<unsigned_type>(hi) -
   75|     16|                 static_cast<unsigned_type>(lo)) {
   76|       |      // [rand.dist.uni.int] precondition 2
   77|       |      assert(lo <= hi);
   78|     16|    }
_ZN4absl12lts_2024011624uniform_int_distributionIjEclINS0_15random_internal17NonsecureURBGBaseINS4_13randen_engineImEENS4_17RandenPoolSeedSeqEEEEEjRT_:
  121|     16|  result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
  122|     16|    return (*this)(gen, param());
  123|     16|  }
_ZN4absl12lts_2024011624uniform_int_distributionIjEclINS0_15random_internal17NonsecureURBGBaseINS4_13randen_engineImEENS4_17RandenPoolSeedSeqEEEEEjRT_RKNS2_10param_typeE:
  127|     16|      URBG& gen, const param_type& param) {  // NOLINT(runtime/references)
  128|     16|    return static_cast<result_type>(param.a() + Generate(gen, param.range()));
  129|     16|  }
_ZN4absl12lts_2024011624uniform_int_distributionIjE8GenerateINS0_15random_internal17NonsecureURBGBaseINS4_13randen_engineImEENS4_17RandenPoolSeedSeqEEEEEjRT_j:
  198|     16|    typename random_internal::make_unsigned_bits<IntType>::type R) {
  199|     16|  random_internal::FastUniformBits<unsigned_type> fast_bits;
  200|     16|  unsigned_type bits = fast_bits(g);
  201|     16|  const unsigned_type Lim = R + 1;
  202|     16|  if ((R & Lim) == 0) {
  ------------------
  |  Branch (202:7): [True: 16, False: 0]
  ------------------
  203|       |    // If the interval's length is a power of two range, just take the low bits.
  204|     16|    return bits & R;
  205|     16|  }
  206|       |
  207|       |  // Generates a uniform variate on [0, Lim) using fixed-point multiplication.
  208|       |  // The above fast-path guarantees that Lim is representable in unsigned_type.
  209|       |  //
  210|       |  // Algorithm adapted from
  211|       |  // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
  212|       |  // explanation.
  213|       |  //
  214|       |  // The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
  215|       |  // and treats it as the fractional part of a fixed-point real value in [0, 1),
  216|       |  // multiplied by 2^N.  For example, 0.25 would be represented as 2^(N - 2),
  217|       |  // because 2^N * 0.25 == 2^(N - 2).
  218|       |  //
  219|       |  // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
  220|       |  // value into the range [0, Lim).  The integral part (the high word of the
  221|       |  // multiplication result) is then very nearly the desired result.  However,
  222|       |  // this is not quite accurate; viewing the multiplication result as one
  223|       |  // double-width integer, the resulting values for the sample are mapped as
  224|       |  // follows:
  225|       |  //
  226|       |  // If the result lies in this interval:       Return this value:
  227|       |  //        [0, 2^N)                                    0
  228|       |  //        [2^N, 2 * 2^N)                              1
  229|       |  //        ...                                         ...
  230|       |  //        [K * 2^N, (K + 1) * 2^N)                    K
  231|       |  //        ...                                         ...
  232|       |  //        [(Lim - 1) * 2^N, Lim * 2^N)                Lim - 1
  233|       |  //
  234|       |  // While all of these intervals have the same size, the result of `bits * Lim`
  235|       |  // must be a multiple of `Lim`, and not all of these intervals contain the
  236|       |  // same number of multiples of `Lim`.  In particular, some contain
  237|       |  // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`.  This
  238|       |  // difference produces a small nonuniformity, which is corrected by applying
  239|       |  // rejection sampling to one of the values in the "larger intervals" (i.e.,
  240|       |  // the intervals containing `F + 1` multiples of `Lim`.
  241|       |  //
  242|       |  // An interval contains `F + 1` multiples of `Lim` if and only if its smallest
  243|       |  // value modulo 2^N is less than `2^N % Lim`.  The unique value satisfying
  244|       |  // this property is used as the one for rejection.  That is, a value of
  245|       |  // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
  246|       |
  247|      0|  using helper = random_internal::wide_multiply<unsigned_type>;
  248|      0|  auto product = helper::multiply(bits, Lim);
  249|       |
  250|       |  // Two optimizations here:
  251|       |  // * Rejection occurs with some probability less than 1/2, and for reasonable
  252|       |  //   ranges considerably less (in particular, less than 1/(F+1)), so
  253|       |  //   ABSL_PREDICT_FALSE is apt.
  254|       |  // * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
  255|      0|  if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  256|       |    // This quantity is exactly equal to `2^N % Lim`, but does not require high
  257|       |    // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
  258|       |    // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
  259|       |    // for types smaller than int, this calculation is incorrect due to integer
  260|       |    // promotion rules.
  261|      0|    const unsigned_type threshold =
  262|      0|        ((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
  263|      0|    while (helper::lo(product) < threshold) {
  ------------------
  |  Branch (263:12): [True: 0, False: 0]
  ------------------
  264|      0|      bits = fast_bits(g);
  265|      0|      product = helper::multiply(bits, Lim);
  266|      0|    }
  267|      0|  }
  268|       |
  269|      0|  return helper::hi(product);
  270|     16|}

_ZN4absl12lts_202401166StatusD2Ev:
  814|  10.0M|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202401166Status5UnrefEm:
  920|  10.0M|inline void Status::Unref(uintptr_t rep) {
  921|  10.0M|  if (!IsInlined(rep)) RepToPointer(rep)->Unref();
  ------------------
  |  Branch (921:7): [True: 0, False: 10.0M]
  ------------------
  922|  10.0M|}
_ZN4absl12lts_202401166Status9IsInlinedEm:
  888|  10.0M|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; }
_ZN4absl12lts_202401168OkStatusEv:
  924|  10.0M|inline Status OkStatus() { return Status(); }
_ZN4absl12lts_202401166StatusC2Ev:
  772|  10.0M|inline Status::Status() : Status(absl::StatusCode::kOk) {}
_ZN4absl12lts_202401166StatusC2ENS0_10StatusCodeE:
  774|  10.0M|inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {}
_ZN4absl12lts_202401166Status16CodeToInlinedRepENS0_10StatusCodeE:
  892|  20.0M|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
  893|  20.0M|  return (static_cast<uintptr_t>(code) << 2) + 1;
  894|  20.0M|}
_ZN4absl12lts_202401166StatusC2Em:
  619|  10.0M|  explicit Status(uintptr_t rep) : rep_(rep) {}
_ZN4absl12lts_202401166StatusaSEOS1_:
  792|  1.18k|inline Status& Status::operator=(Status&& x) {
  793|  1.18k|  uintptr_t old_rep = rep_;
  794|  1.18k|  if (x.rep_ != old_rep) {
  ------------------
  |  Branch (794:7): [True: 0, False: 1.18k]
  ------------------
  795|      0|    rep_ = x.rep_;
  796|      0|    x.rep_ = MovedFromRep();
  797|      0|    Unref(old_rep);
  798|      0|  }
  799|  1.18k|  return *this;
  800|  1.18k|}
_ZNK4absl12lts_202401166Status2okEv:
  816|  10.0M|inline bool Status::ok() const {
  817|  10.0M|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
  818|  10.0M|}
_ZN4absl12lts_202401166Status3RefEm:
  916|  1.18k|inline void Status::Ref(uintptr_t rep) {
  917|  1.18k|  if (!IsInlined(rep)) RepToPointer(rep)->Ref();
  ------------------
  |  Branch (917:7): [True: 0, False: 1.18k]
  ------------------
  918|  1.18k|}
_ZN4absl12lts_202401166StatusC2ERKS1_:
  776|  1.18k|inline Status::Status(const Status& x) : Status(x.rep_) { Ref(rep_); }

_ZN4absl12lts_2024011613ascii_isspaceEh:
   97|  1.38M|inline bool ascii_isspace(unsigned char c) {
   98|  1.38M|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
   99|  1.38M|}
_ZN4absl12lts_2024011627StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  200|  24.5k|    absl::string_view str) {
  201|  24.5k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  202|  24.5k|  return str.substr(static_cast<size_t>(it - str.begin()));
  203|  24.5k|}
_ZN4absl12lts_2024011628StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  214|  24.5k|    absl::string_view str) {
  215|  24.5k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  216|  24.5k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  217|  24.5k|}
_ZN4absl12lts_2024011620StripAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  228|  24.5k|    absl::string_view str) {
  229|  24.5k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  230|  24.5k|}

_ZN4absl12lts_2024011610from_charsEPKcS2_RdNS0_12chars_formatE:
  953|  24.5k|                             chars_format fmt) {
  954|  24.5k|  return FromCharsImpl(first, last, value, fmt);
  955|  24.5k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  866|  24.5k|                                FloatType& value, chars_format fmt_flags) {
  867|  24.5k|  from_chars_result result;
  868|  24.5k|  result.ptr = first;  // overwritten on successful parse
  869|  24.5k|  result.ec = std::errc();
  870|       |
  871|  24.5k|  bool negative = false;
  872|  24.5k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (872:7): [True: 24.5k, False: 9]
  |  Branch (872:24): [True: 1.77k, False: 22.8k]
  ------------------
  873|  1.77k|    ++first;
  874|  1.77k|    negative = true;
  875|  1.77k|  }
  876|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  877|       |  // to parse a hexadecimal float.
  878|  24.5k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (878:7): [True: 24.5k, False: 0]
  |  Branch (878:60): [True: 22.5k, False: 2.07k]
  ------------------
  879|  22.5k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (879:7): [True: 6.15k, False: 16.3k]
  |  Branch (879:25): [True: 565, False: 5.59k]
  |  Branch (879:44): [True: 4.56k, False: 1.02k]
  ------------------
  880|  5.13k|    const char* hex_first = first + 2;
  881|  5.13k|    strings_internal::ParsedFloat hex_parse =
  882|  5.13k|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  883|  5.13k|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (883:9): [True: 49, False: 5.08k]
  ------------------
  884|  5.08k|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (884:9): [True: 1, False: 5.08k]
  ------------------
  885|       |      // Either we failed to parse a hex float after the "0x", or we read
  886|       |      // "0xinf" or "0xnan" which we don't want to match.
  887|       |      //
  888|       |      // However, a string that begins with "0x" also begins with "0", which
  889|       |      // is normally a valid match for the number zero.  So we want these
  890|       |      // strings to match zero unless fmt_flags is `scientific`.  (This flag
  891|       |      // means an exponent is required, which the string "0" does not have.)
  892|     50|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (892:11): [True: 0, False: 50]
  ------------------
  893|      0|        result.ec = std::errc::invalid_argument;
  894|     50|      } else {
  895|     50|        result.ptr = first + 1;
  896|     50|        value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (896:17): [True: 1, False: 49]
  ------------------
  897|     50|      }
  898|     50|      return result;
  899|     50|    }
  900|       |    // We matched a value.
  901|  5.08k|    result.ptr = hex_parse.end;
  902|  5.08k|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (902:9): [True: 1.07k, False: 4.01k]
  ------------------
  903|  1.07k|      return result;
  904|  1.07k|    }
  905|  4.01k|    CalculatedFloat calculated =
  906|  4.01k|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  907|  4.01k|    EncodeResult(calculated, negative, &result, &value);
  908|  4.01k|    return result;
  909|  5.08k|  }
  910|       |  // Otherwise, we choose the number base based on the flags.
  911|  19.4k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (911:7): [True: 0, False: 19.4k]
  ------------------
  912|      0|    strings_internal::ParsedFloat hex_parse =
  913|      0|        strings_internal::ParseFloat<16>(first, last, fmt_flags);
  914|      0|    if (hex_parse.end == nullptr) {
  ------------------
  |  Branch (914:9): [True: 0, False: 0]
  ------------------
  915|      0|      result.ec = std::errc::invalid_argument;
  916|      0|      return result;
  917|      0|    }
  918|      0|    result.ptr = hex_parse.end;
  919|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (919:9): [True: 0, False: 0]
  ------------------
  920|      0|      return result;
  921|      0|    }
  922|      0|    CalculatedFloat calculated =
  923|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  924|      0|    EncodeResult(calculated, negative, &result, &value);
  925|      0|    return result;
  926|  19.4k|  } else {
  927|  19.4k|    strings_internal::ParsedFloat decimal_parse =
  928|  19.4k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  929|  19.4k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (929:9): [True: 149, False: 19.3k]
  ------------------
  930|    149|      result.ec = std::errc::invalid_argument;
  931|    149|      return result;
  932|    149|    }
  933|  19.3k|    result.ptr = decimal_parse.end;
  934|  19.3k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (934:9): [True: 3.41k, False: 15.9k]
  ------------------
  935|  3.41k|      return result;
  936|  3.41k|    }
  937|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  938|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  939|  15.9k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (939:9): [True: 7.61k, False: 8.29k]
  ------------------
  940|  7.61k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (940:9): [True: 4.40k, False: 3.21k]
  ------------------
  941|  4.40k|      return result;
  942|  4.40k|    }
  943|  11.5k|    CalculatedFloat calculated =
  944|  11.5k|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  945|  11.5k|    EncodeResult(calculated, negative, &result, &value);
  946|  11.5k|    return result;
  947|  15.9k|  }
  948|  19.4k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  24.3k|                    absl::Nonnull<FloatType*> value) {
  361|  24.3k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 437, False: 23.9k]
  ------------------
  362|       |    // A bug in both clang < 7 and gcc would cause the compiler to optimize
  363|       |    // away the buffer we are building below.  Declaring the buffer volatile
  364|       |    // avoids the issue, and has no measurable performance impact in
  365|       |    // microbenchmarks.
  366|       |    //
  367|       |    // https://bugs.llvm.org/show_bug.cgi?id=37778
  368|       |    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
  369|    437|    constexpr ptrdiff_t kNanBufferSize = 128;
  370|       |#if (defined(__GNUC__) && !defined(__clang__)) || \
  371|       |    (defined(__clang__) && __clang_major__ < 7)
  372|       |    volatile char n_char_sequence[kNanBufferSize];
  373|       |#else
  374|    437|    char n_char_sequence[kNanBufferSize];
  375|    437|#endif
  376|    437|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (376:9): [True: 437, False: 0]
  ------------------
  377|    437|      n_char_sequence[0] = '\0';
  378|    437|    } else {
  379|      0|      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
  380|      0|      nan_size = std::min(nan_size, kNanBufferSize - 1);
  381|      0|      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
  382|      0|      n_char_sequence[nan_size] = '\0';
  383|      0|    }
  384|    437|    char* nan_argument = const_cast<char*>(n_char_sequence);
  385|    437|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (385:14): [True: 1, False: 436]
  ------------------
  386|    437|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  387|    437|    return true;
  388|    437|  }
  389|  23.9k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (389:7): [True: 656, False: 23.3k]
  ------------------
  390|    656|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (390:14): [True: 0, False: 656]
  ------------------
  391|    656|                      : std::numeric_limits<FloatType>::infinity();
  392|    656|    return true;
  393|    656|  }
  394|  23.3k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (394:7): [True: 3.38k, False: 19.9k]
  ------------------
  395|  3.38k|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (395:14): [True: 183, False: 3.20k]
  ------------------
  396|  3.38k|    return true;
  397|  3.38k|  }
  398|  19.9k|  return false;
  399|  23.3k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111FloatTraitsIdE7MakeNanEPKc:
  123|    437|  static double MakeNan(absl::Nonnull<const char*> tagp) {
  124|    437|#if ABSL_HAVE_BUILTIN(__builtin_nan)
  125|       |    // Use __builtin_nan() if available since it has a fix for
  126|       |    // https://bugs.llvm.org/show_bug.cgi?id=37778
  127|       |    // std::nan may use the glibc implementation.
  128|    437|    return __builtin_nan(tagp);
  129|       |#else
  130|       |    // Support nan no matter which namespace it's in.  Some platforms
  131|       |    // incorrectly don't put it in namespace std.
  132|       |    using namespace std;  // NOLINT
  133|       |    return nan(tagp);
  134|       |#endif
  135|    437|  }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_130CalculateFromParsedHexadecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  602|  4.01k|    const strings_internal::ParsedFloat& parsed_hex) {
  603|  4.01k|  uint64_t mantissa = parsed_hex.mantissa;
  604|  4.01k|  int exponent = parsed_hex.exponent;
  605|       |  // This static_cast is only needed when using a std::bit_width()
  606|       |  // implementation that does not have the fix for LWG 3656 applied.
  607|  4.01k|  int mantissa_width = static_cast<int>(bit_width(mantissa));
  608|  4.01k|  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
  609|  4.01k|  bool result_exact;
  610|  4.01k|  exponent += shift;
  611|  4.01k|  mantissa = ShiftRightAndRound(mantissa, shift,
  612|  4.01k|                                /* input exact= */ true, &result_exact);
  613|       |  // ParseFloat handles rounding in the hexadecimal case, so we don't have to
  614|       |  // check `result_exact` here.
  615|  4.01k|  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
  616|  4.01k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|  15.0k|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|  15.0k|  const int normal_shift =
  337|  15.0k|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|  15.0k|  const int minimum_shift =
  339|  15.0k|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|  15.0k|  return std::max(normal_shift, minimum_shift);
  341|  15.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  456|  15.0k|                            absl::Nonnull<bool*> output_exact) {
  457|  15.0k|  if (shift <= 0) {
  ------------------
  |  Branch (457:7): [True: 2.27k, False: 12.7k]
  ------------------
  458|  2.27k|    *output_exact = input_exact;
  459|  2.27k|    return static_cast<uint64_t>(value << -shift);
  460|  2.27k|  }
  461|  12.7k|  if (shift >= 128) {
  ------------------
  |  Branch (461:7): [True: 228, False: 12.5k]
  ------------------
  462|       |    // Exponent is so small that we are shifting away all significant bits.
  463|       |    // Answer will not be representable, even as a subnormal, so return a zero
  464|       |    // mantissa (which represents underflow).
  465|    228|    *output_exact = true;
  466|    228|    return 0;
  467|    228|  }
  468|       |
  469|  12.5k|  *output_exact = true;
  470|  12.5k|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  471|  12.5k|  const uint128 halfway_point = uint128(1) << (shift - 1);
  472|       |
  473|  12.5k|  const uint128 shifted_bits = value & shift_mask;
  474|  12.5k|  value >>= shift;
  475|  12.5k|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (475:7): [True: 1.17k, False: 11.3k]
  ------------------
  476|       |    // Shifted bits greater than 10000... require rounding up.
  477|  1.17k|    return static_cast<uint64_t>(value + 1);
  478|  1.17k|  }
  479|  11.3k|  if (shifted_bits == halfway_point) {
  ------------------
  |  Branch (479:7): [True: 1.23k, False: 10.1k]
  ------------------
  480|       |    // In exact mode, shifted bits of 10000... mean we're exactly halfway
  481|       |    // between two numbers, and we must round to even.  So only round up if
  482|       |    // the low bit of `value` is set.
  483|       |    //
  484|       |    // In inexact mode, the nonzero error means the actual value is greater
  485|       |    // than the halfway point and we must always round up.
  486|  1.23k|    if ((value & 1) == 1 || !input_exact) {
  ------------------
  |  Branch (486:9): [True: 396, False: 836]
  |  Branch (486:29): [True: 194, False: 642]
  ------------------
  487|    590|      ++value;
  488|    590|    }
  489|  1.23k|    return static_cast<uint64_t>(value);
  490|  1.23k|  }
  491|  10.1k|  if (!input_exact && shifted_bits == halfway_point - 1) {
  ------------------
  |  Branch (491:7): [True: 9.41k, False: 733]
  |  Branch (491:23): [True: 9.00k, False: 404]
  ------------------
  492|       |    // Rounding direction is unclear, due to error.
  493|  9.00k|    *output_exact = false;
  494|  9.00k|  }
  495|       |  // Otherwise, round down.
  496|  10.1k|  return static_cast<uint64_t>(value);
  497|  11.3k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  583|  15.0k|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  584|  15.0k|  CalculatedFloat result;
  585|  15.0k|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (585:7): [True: 596, False: 14.4k]
  ------------------
  586|    596|    mantissa >>= 1;
  587|    596|    exponent += 1;
  588|    596|  }
  589|  15.0k|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (589:7): [True: 1.58k, False: 13.4k]
  ------------------
  590|  1.58k|    result.exponent = kOverflow;
  591|  13.4k|  } else if (mantissa == 0) {
  ------------------
  |  Branch (591:14): [True: 755, False: 12.7k]
  ------------------
  592|    755|    result.exponent = kUnderflow;
  593|  12.7k|  } else {
  594|  12.7k|    result.exponent = exponent;
  595|  12.7k|    result.mantissa = mantissa;
  596|  12.7k|  }
  597|  15.0k|  return result;
  598|  15.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  410|  15.5k|                  absl::Nonnull<FloatType*> value) {
  411|  15.5k|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (411:7): [True: 1.81k, False: 13.7k]
  ------------------
  412|  1.81k|    result->ec = std::errc::result_out_of_range;
  413|  1.81k|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (413:14): [True: 13, False: 1.79k]
  ------------------
  414|  1.81k|                      : std::numeric_limits<FloatType>::max();
  415|  1.81k|    return;
  416|  13.7k|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (416:14): [True: 986, False: 12.7k]
  |  Branch (416:42): [True: 0, False: 12.7k]
  ------------------
  417|    986|    result->ec = std::errc::result_out_of_range;
  418|    986|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (418:14): [True: 0, False: 986]
  ------------------
  419|    986|    return;
  420|    986|  }
  421|  12.7k|  *value = FloatTraits<FloatType>::Make(
  422|  12.7k|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  423|  12.7k|          calculated.mantissa),
  424|  12.7k|      calculated.exponent, negative);
  425|  12.7k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|  12.7k|  static double Make(mantissa_t mantissa, int exponent, bool sign) {
  151|       |#ifndef ABSL_BIT_PACK_FLOATS
  152|       |    // Support ldexp no matter which namespace it's in.  Some platforms
  153|       |    // incorrectly don't put it in namespace std.
  154|       |    using namespace std;  // NOLINT
  155|       |    return sign ? -ldexp(mantissa, exponent) : ldexp(mantissa, exponent);
  156|       |#else
  157|  12.7k|    constexpr uint64_t kMantissaMask =
  158|  12.7k|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|  12.7k|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|  12.7k|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 12.1k, False: 533]
  ------------------
  161|       |      // Normal value.
  162|       |      // Adjust by 1023 for the exponent representation bias, and an additional
  163|       |      // 52 due to the implied decimal point in the IEEE mantissa
  164|       |      // representation.
  165|  12.1k|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|  12.1k|             << 52;
  167|  12.1k|      mantissa &= kMantissaMask;
  168|  12.1k|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|    533|    }
  172|  12.7k|    dbl += mantissa;
  173|  12.7k|    return absl::bit_cast<double>(dbl);
  174|  12.7k|#endif  // ABSL_BIT_PACK_FLOATS
  175|  12.7k|  }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  691|  7.61k|                 absl::Nonnull<std::errc*> ec) {
  692|  7.61k|  uint64_t man = input.mantissa;
  693|  7.61k|  int exp10 = input.exponent;
  694|  7.61k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (694:7): [True: 239, False: 7.37k]
  ------------------
  695|    239|    *value = negative ? -0.0 : 0.0;
  ------------------
  |  Branch (695:14): [True: 10, False: 229]
  ------------------
  696|    239|    *ec = std::errc::result_out_of_range;
  697|    239|    return true;
  698|  7.37k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (698:14): [True: 565, False: 6.80k]
  ------------------
  699|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  700|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  701|    565|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (701:14): [True: 195, False: 370]
  ------------------
  702|    565|                      : std::numeric_limits<FloatType>::max();
  703|    565|    *ec = std::errc::result_out_of_range;
  704|    565|    return true;
  705|    565|  }
  706|       |
  707|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  708|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  709|  6.80k|  static_assert(
  710|  6.80k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  711|  6.80k|          kPower10TableMinInclusive,
  712|  6.80k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|  6.80k|  static_assert(
  714|  6.80k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  715|  6.80k|          kPower10TableMaxExclusive,
  716|  6.80k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  717|       |
  718|       |  // The terse (+) comments in this function body refer to sections of the
  719|       |  // https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
  720|       |  //
  721|       |  // That blog post discusses double precision (11 exponent bits with a -1023
  722|       |  // bias, 52 mantissa bits), but the same approach applies to single precision
  723|       |  // (8 exponent bits with a -127 bias, 23 mantissa bits). Either way, the
  724|       |  // computation here happens with 64-bit values (e.g. man) or 128-bit values
  725|       |  // (e.g. x) before finally converting to 64- or 32-bit floating point.
  726|       |  //
  727|       |  // See also "Number Parsing at a Gigabyte per Second, Software: Practice and
  728|       |  // Experience 51 (8), 2021" (https://arxiv.org/abs/2101.11408) for detail.
  729|       |
  730|       |  // (+) Normalization.
  731|  6.80k|  int clz = countl_zero(man);
  732|  6.80k|  man <<= static_cast<unsigned int>(clz);
  733|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  734|  6.80k|  uint64_t ret_exp2 =
  735|  6.80k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  736|  6.80k|                            FloatTraits<FloatType>::kExponentBias - clz);
  737|       |
  738|       |  // (+) Multiplication.
  739|  6.80k|  uint128 x = static_cast<uint128>(man) *
  740|  6.80k|              static_cast<uint128>(
  741|  6.80k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  742|       |
  743|       |  // (+) Wider Approximation.
  744|  6.80k|  static constexpr uint64_t high64_mask =
  745|  6.80k|      FloatTraits<FloatType>::kEiselLemireMask;
  746|  6.80k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (746:7): [True: 2.38k, False: 4.42k]
  ------------------
  747|  2.38k|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (747:7): [True: 2.02k, False: 361]
  ------------------
  748|  2.02k|    uint128 y =
  749|  2.02k|        static_cast<uint128>(man) *
  750|  2.02k|        static_cast<uint128>(
  751|  2.02k|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  752|  2.02k|    x += Uint128High64(y);
  753|       |    // For example, parsing "4503599627370497.5" will take the if-true
  754|       |    // branch here (for double precision), since:
  755|       |    //  - x   = 0x8000000000000BFF_FFFFFFFFFFFFFFFF
  756|       |    //  - y   = 0x8000000000000BFF_7FFFFFFFFFFFF400
  757|       |    //  - man = 0xA000000000000F00
  758|       |    // Likewise, when parsing "0.0625" for single precision:
  759|       |    //  - x   = 0x7FFFFFFFFFFFFFFF_FFFFFFFFFFFFFFFF
  760|       |    //  - y   = 0x813FFFFFFFFFFFFF_8A00000000000000
  761|       |    //  - man = 0x9C40000000000000
  762|  2.02k|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (762:9): [True: 1.49k, False: 532]
  ------------------
  763|  1.49k|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (763:9): [True: 976, False: 515]
  ------------------
  764|    976|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (764:9): [True: 976, False: 0]
  ------------------
  765|    976|      return false;
  766|    976|    }
  767|  2.02k|  }
  768|       |
  769|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  770|  5.83k|  uint64_t msb = Uint128High64(x) >> 63;
  771|  5.83k|  uint64_t ret_man =
  772|  5.83k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  773|  5.83k|  ret_exp2 -= 1 ^ msb;
  774|       |
  775|       |  // (+) Half-way Ambiguity.
  776|       |  //
  777|       |  // For example, parsing "1e+23" will take the if-true branch here (for double
  778|       |  // precision), since:
  779|       |  //  - x       = 0x54B40B1F852BDA00_0000000000000000
  780|       |  //  - ret_man = 0x002A5A058FC295ED
  781|       |  // Likewise, when parsing "20040229.0" for single precision:
  782|       |  //  - x       = 0x4C72894000000000_0000000000000000
  783|       |  //  - ret_man = 0x000000000131CA25
  784|  5.83k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (784:7): [True: 3.59k, False: 2.23k]
  |  Branch (784:33): [True: 2.52k, False: 1.07k]
  ------------------
  785|  2.52k|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (785:7): [True: 449, False: 2.08k]
  ------------------
  786|    449|    return false;
  787|    449|  }
  788|       |
  789|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  790|  5.38k|  ret_man += ret_man & 1;  // Line From54a.
  791|  5.38k|  ret_man >>= 1;           // Line From54b.
  792|       |  // Incrementing ret_man (at line From54a) may have overflowed 54 bits (53
  793|       |  // bits after the right shift by 1 at line From54b), so adjust for that.
  794|       |  //
  795|       |  // For example, parsing "9223372036854775807" will take the if-true branch
  796|       |  // here (for double precision), since:
  797|       |  //  - ret_man = 0x0020000000000000 = (1 << 53)
  798|       |  // Likewise, when parsing "2147483647.0" for single precision:
  799|       |  //  - ret_man = 0x0000000001000000 = (1 << 24)
  800|  5.38k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (800:7): [True: 205, False: 5.17k]
  ------------------
  801|    205|    ret_exp2 += 1;
  802|       |    // Conceptually, we need a "ret_man >>= 1" in this if-block to balance
  803|       |    // incrementing ret_exp2 in the line immediately above. However, we only
  804|       |    // get here when line From54a overflowed (after adding a 1), so ret_man
  805|       |    // here is (1 << 53). Its low 53 bits are therefore all zeroes. The only
  806|       |    // remaining use of ret_man is to mask it with ((1 << 52) - 1), so only its
  807|       |    // low 52 bits matter. A "ret_man >>= 1" would have no effect in practice.
  808|       |    //
  809|       |    // We omit the "ret_man >>= 1", even if it is cheap (and this if-branch is
  810|       |    // rarely taken) and technically 'more correct', so that mutation tests
  811|       |    // that would otherwise modify or omit that "ret_man >>= 1" don't complain
  812|       |    // that such code mutations have no observable effect.
  813|    205|  }
  814|       |
  815|       |  // ret_exp2 is a uint64_t. Zero or underflow means that we're in subnormal
  816|       |  // space. max_exp2 (0x7FF for double precision, 0xFF for single precision) or
  817|       |  // above means that we're in Inf/NaN space.
  818|       |  //
  819|       |  // The if block is equivalent to (but has fewer branches than):
  820|       |  //   if ((ret_exp2 <= 0) || (ret_exp2 >= max_exp2)) { etc }
  821|       |  //
  822|       |  // For example, parsing "4.9406564584124654e-324" will take the if-true
  823|       |  // branch here, since ret_exp2 = -51.
  824|  5.38k|  static constexpr uint64_t max_exp2 =
  825|  5.38k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  826|  5.38k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (826:7): [True: 1.78k, False: 3.59k]
  ------------------
  827|  1.78k|    return false;
  828|  1.78k|  }
  829|       |
  830|       |#ifndef ABSL_BIT_PACK_FLOATS
  831|       |  if (FloatTraits<FloatType>::kTargetBits == 64) {
  832|       |    *value = FloatTraits<FloatType>::Make(
  833|       |        (ret_man & 0x000FFFFFFFFFFFFFu) | 0x0010000000000000u,
  834|       |        static_cast<int>(ret_exp2) - 1023 - 52, negative);
  835|       |    return true;
  836|       |  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  837|       |    *value = FloatTraits<FloatType>::Make(
  838|       |        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu) | 0x00800000u,
  839|       |        static_cast<int>(ret_exp2) - 127 - 23, negative);
  840|       |    return true;
  841|       |  }
  842|       |#else
  843|  3.59k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (843:7): [True: 3.59k, Folded]
  ------------------
  844|  3.59k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  845|  3.59k|    if (negative) {
  ------------------
  |  Branch (845:9): [True: 364, False: 3.23k]
  ------------------
  846|    364|      ret_bits |= 0x8000000000000000u;
  847|    364|    }
  848|  3.59k|    *value = absl::bit_cast<double>(ret_bits);
  849|  3.59k|    return true;
  850|  3.59k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (850:14): [Folded, False: 0]
  ------------------
  851|      0|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  852|      0|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  853|      0|    if (negative) {
  ------------------
  |  Branch (853:9): [True: 0, False: 0]
  ------------------
  854|      0|      ret_bits |= 0x80000000u;
  855|      0|    }
  856|      0|    *value = absl::bit_cast<float>(ret_bits);
  857|      0|    return true;
  858|      0|  }
  859|      0|#endif  // ABSL_BIT_PACK_FLOATS
  860|      0|  return false;
  861|  3.59k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  620|  11.5k|    const strings_internal::ParsedFloat& parsed_decimal) {
  621|  11.5k|  CalculatedFloat result;
  622|       |
  623|       |  // Large or small enough decimal exponents will always result in overflow
  624|       |  // or underflow.
  625|  11.5k|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:7): [True: 231, False: 11.2k]
  ------------------
  626|    231|    result.exponent = kUnderflow;
  627|    231|    return result;
  628|  11.2k|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (628:14): [True: 228, False: 11.0k]
  ------------------
  629|    228|    result.exponent = kOverflow;
  630|    228|    return result;
  631|    228|  }
  632|       |
  633|       |  // Otherwise convert our power of 10 into a power of 2 times an integer
  634|       |  // mantissa, and multiply this by our parsed decimal mantissa.
  635|  11.0k|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  636|  11.0k|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  637|  11.0k|  int binary_exponent = Power10Exponent(parsed_decimal.exponent);
  638|       |
  639|       |  // Discard bits that are inaccurate due to truncation error.  The magic
  640|       |  // `mantissa_width` constants below are justified in
  641|       |  // https://abseil.io/about/design/charconv. They represent the number of bits
  642|       |  // in `wide_binary_mantissa` that are guaranteed to be unaffected by error
  643|       |  // propagation.
  644|  11.0k|  bool mantissa_exact;
  645|  11.0k|  int mantissa_width;
  646|  11.0k|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (646:7): [True: 7.83k, False: 3.21k]
  ------------------
  647|       |    // Truncated mantissa
  648|  7.83k|    mantissa_width = 58;
  649|  7.83k|    mantissa_exact = false;
  650|  7.83k|    binary_exponent +=
  651|  7.83k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  652|  7.83k|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (652:14): [True: 2.76k, False: 449]
  ------------------
  653|       |    // Exact mantissa, truncated power of ten
  654|  2.76k|    mantissa_width = 63;
  655|  2.76k|    mantissa_exact = false;
  656|  2.76k|    binary_exponent +=
  657|  2.76k|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  658|  2.76k|  } else {
  659|       |    // Product is exact
  660|    449|    mantissa_width = BitWidth(wide_binary_mantissa);
  661|    449|    mantissa_exact = true;
  662|    449|  }
  663|       |
  664|       |  // Shift into an FloatType-sized mantissa, and round to nearest.
  665|  11.0k|  const int shift =
  666|  11.0k|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  667|  11.0k|  bool result_exact;
  668|  11.0k|  binary_exponent += shift;
  669|  11.0k|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  670|  11.0k|                                                mantissa_exact, &result_exact);
  671|  11.0k|  if (!result_exact) {
  ------------------
  |  Branch (671:7): [True: 9.00k, False: 2.03k]
  ------------------
  672|       |    // We could not determine the rounding direction using int128 math.  Use
  673|       |    // full resolution math instead.
  674|  9.00k|    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
  ------------------
  |  Branch (674:9): [True: 2.31k, False: 6.69k]
  ------------------
  675|  2.31k|      binary_mantissa += 1;
  676|  2.31k|    }
  677|  9.00k|  }
  678|       |
  679|  11.0k|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  680|  11.0k|                                                 binary_exponent);
  681|  11.5k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_116Power10UnderflowEi:
  288|  11.5k|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10OverflowEi:
  284|  11.2k|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10MantissaEi:
  270|  11.0k|uint64_t Power10Mantissa(int n) {
  271|  11.0k|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|  11.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115Power10ExponentEi:
  274|  11.0k|int Power10Exponent(int n) {
  275|       |  // The 217706 etc magic numbers encode the results as a formula instead of a
  276|       |  // table. Their equivalence (over the kPower10TableMinInclusive ..
  277|       |  // kPower10TableMaxExclusive range) is confirmed by
  278|       |  // https://github.com/google/wuffs/blob/315b2e52625ebd7b02d8fac13e3cd85ea374fb80/script/print-mpb-powers-of-10.go
  279|  11.0k|  return (217706 * n >> 16) - 63;
  280|  11.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|  10.5k|int TruncateToBitWidth(int bit_width, absl::Nonnull<uint128*> value) {
  349|  10.5k|  const int current_bit_width = BitWidth(*value);
  350|  10.5k|  const int shift = current_bit_width - bit_width;
  351|  10.5k|  *value >>= shift;
  352|  10.5k|  return shift;
  353|  10.5k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_112Power10ExactEi:
  293|  3.21k|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 1.79k, False: 1.41k]
  |  Branch (293:45): [True: 449, False: 1.34k]
  ------------------
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|  11.0k|int BitWidth(uint128 value) {
  318|  11.0k|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 529, False: 10.5k]
  ------------------
  319|       |    // This static_cast is only needed when using a std::bit_width()
  320|       |    // implementation that does not have the fix for LWG 3656 applied.
  321|    529|    return static_cast<int>(bit_width(Uint128Low64(value)));
  322|    529|  }
  323|  10.5k|  return 128 - countl_zero(Uint128High64(value));
  324|  11.0k|}
charconv.cc:_ZN4absl12lts_2024011612_GLOBAL__N_111MustRoundUpEmiRKNS0_16strings_internal11ParsedFloatE:
  513|  9.00k|                 const strings_internal::ParsedFloat& parsed_decimal) {
  514|       |  // 768 is the number of digits needed in the worst case.  We could determine a
  515|       |  // better limit dynamically based on the value of parsed_decimal.exponent.
  516|       |  // This would optimize pathological input cases only.  (Sane inputs won't have
  517|       |  // hundreds of digits of mantissa.)
  518|  9.00k|  absl::strings_internal::BigUnsigned<84> exact_mantissa;
  519|  9.00k|  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
  520|       |
  521|       |  // Adjust the `guess` arguments to be halfway between A and B.
  522|  9.00k|  guess_mantissa = guess_mantissa * 2 + 1;
  523|  9.00k|  guess_exponent -= 1;
  524|       |
  525|       |  // In our comparison:
  526|       |  // lhs = exact = exact_mantissa * 10**exact_exponent
  527|       |  //             = exact_mantissa * 5**exact_exponent * 2**exact_exponent
  528|       |  // rhs = guess = guess_mantissa * 2**guess_exponent
  529|       |  //
  530|       |  // Because we are doing integer math, we can't directly deal with negative
  531|       |  // exponents.  We instead move these to the other side of the inequality.
  532|  9.00k|  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
  533|  9.00k|  int comparison;
  534|  9.00k|  if (exact_exponent >= 0) {
  ------------------
  |  Branch (534:7): [True: 3.05k, False: 5.94k]
  ------------------
  535|  3.05k|    lhs.MultiplyByFiveToTheNth(exact_exponent);
  536|  3.05k|    absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa);
  537|       |    // There are powers of 2 on both sides of the inequality; reduce this to
  538|       |    // a single bit-shift.
  539|  3.05k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (539:9): [True: 0, False: 3.05k]
  ------------------
  540|      0|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  541|  3.05k|    } else {
  542|  3.05k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  543|  3.05k|    }
  544|  3.05k|    comparison = Compare(lhs, rhs);
  545|  5.94k|  } else {
  546|       |    // Move the power of 5 to the other side of the equation, giving us:
  547|       |    // lhs = exact_mantissa * 2**exact_exponent
  548|       |    // rhs = guess_mantissa * 5**(-exact_exponent) * 2**guess_exponent
  549|  5.94k|    absl::strings_internal::BigUnsigned<84> rhs =
  550|  5.94k|        absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_exponent);
  551|  5.94k|    rhs.MultiplyBy(guess_mantissa);
  552|  5.94k|    if (exact_exponent > guess_exponent) {
  ------------------
  |  Branch (552:9): [True: 2.07k, False: 3.87k]
  ------------------
  553|  2.07k|      lhs.ShiftLeft(exact_exponent - guess_exponent);
  554|  3.87k|    } else {
  555|  3.87k|      rhs.ShiftLeft(guess_exponent - exact_exponent);
  556|  3.87k|    }
  557|  5.94k|    comparison = Compare(lhs, rhs);
  558|  5.94k|  }
  559|  9.00k|  if (comparison < 0) {
  ------------------
  |  Branch (559:7): [True: 6.17k, False: 2.83k]
  ------------------
  560|  6.17k|    return false;
  561|  6.17k|  } else if (comparison > 0) {
  ------------------
  |  Branch (561:14): [True: 1.93k, False: 900]
  ------------------
  562|  1.93k|    return true;
  563|  1.93k|  } else {
  564|       |    // When lhs == rhs, the decimal input is exactly between A and B.
  565|       |    // Round towards even -- round up only if the low bit of the initial
  566|       |    // `guess_mantissa` was a 1.  We shifted guess_mantissa left 1 bit at
  567|       |    // the beginning of this function, so test the 2nd bit here.
  568|    900|    return (guess_mantissa & 2) == 2;
  569|    900|  }
  570|  9.00k|}

_ZN4absl12lts_20240116anENS0_12chars_formatES1_:
   92|   116k|inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
   93|   116k|  return static_cast<chars_format>(static_cast<int>(lhs) &
   94|   116k|                                   static_cast<int>(rhs));
   95|   116k|}

_ZN4absl12lts_2024011619WebSafeBase64EscapeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  914|      2|std::string WebSafeBase64Escape(absl::string_view src) {
  915|      2|  std::string dest;
  916|      2|  strings_internal::Base64EscapeInternal(
  917|      2|      reinterpret_cast<const unsigned char*>(src.data()), src.size(), &dest,
  918|      2|      false, strings_internal::kWebSafeBase64Chars);
  919|      2|  return dest;
  920|      2|}

_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE17ReadFloatMantissaERKNS1_11ParsedFloatEi:
  172|  9.00k|                                              int significant_digits) {
  173|  9.00k|  SetToZero();
  174|  9.00k|  assert(fp.type == FloatType::kNumber);
  175|       |
  176|  9.00k|  if (fp.subrange_begin == nullptr) {
  ------------------
  |  Branch (176:7): [True: 1.65k, False: 7.34k]
  ------------------
  177|       |    // We already exactly parsed the mantissa, so no more work is necessary.
  178|  1.65k|    words_[0] = fp.mantissa & 0xffffffffu;
  179|  1.65k|    words_[1] = fp.mantissa >> 32;
  180|  1.65k|    if (words_[1]) {
  ------------------
  |  Branch (180:9): [True: 539, False: 1.12k]
  ------------------
  181|    539|      size_ = 2;
  182|  1.12k|    } else if (words_[0]) {
  ------------------
  |  Branch (182:16): [True: 1.12k, False: 0]
  ------------------
  183|  1.12k|      size_ = 1;
  184|  1.12k|    }
  185|  1.65k|    return fp.exponent;
  186|  1.65k|  }
  187|  7.34k|  int exponent_adjust =
  188|  7.34k|      ReadDigits(fp.subrange_begin, fp.subrange_end, significant_digits);
  189|  7.34k|  return fp.literal_exponent + exponent_adjust;
  190|  9.00k|}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12FiveToTheNthEi:
  289|  5.94k|    int n) {
  290|  5.94k|  BigUnsigned answer(1u);
  291|       |
  292|       |  // Seed from the table of large powers, if possible.
  293|  5.94k|  bool first_pass = true;
  294|  11.9k|  while (n >= kLargePowerOfFiveStep) {
  ------------------
  |  Branch (294:10): [True: 5.98k, False: 5.94k]
  ------------------
  295|  5.98k|    int big_power =
  296|  5.98k|        std::min(n / kLargePowerOfFiveStep, kLargestPowerOfFiveIndex);
  297|  5.98k|    if (first_pass) {
  ------------------
  |  Branch (297:9): [True: 3.66k, False: 2.32k]
  ------------------
  298|       |      // just copy, rather than multiplying by 1
  299|  3.66k|      std::copy_n(LargePowerOfFiveData(big_power),
  300|  3.66k|                  LargePowerOfFiveSize(big_power), answer.words_);
  301|  3.66k|      answer.size_ = LargePowerOfFiveSize(big_power);
  302|  3.66k|      first_pass = false;
  303|  3.66k|    } else {
  304|  2.32k|      answer.MultiplyBy(LargePowerOfFiveSize(big_power),
  305|  2.32k|                        LargePowerOfFiveData(big_power));
  306|  2.32k|    }
  307|  5.98k|    n -= kLargePowerOfFiveStep * big_power;
  308|  5.98k|  }
  309|  5.94k|  answer.MultiplyByFiveToTheNth(n);
  310|  5.94k|  return answer;
  311|  5.94k|}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10ReadDigitsEPKcS5_i:
  194|  7.34k|                                       int significant_digits) {
  195|  7.34k|  assert(significant_digits <= Digits10() + 1);
  196|  7.34k|  SetToZero();
  197|       |
  198|  7.34k|  bool after_decimal_point = false;
  199|       |  // Discard any leading zeroes before the decimal point
  200|  7.54k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (200:10): [True: 7.54k, False: 0]
  |  Branch (200:25): [True: 198, False: 7.34k]
  ------------------
  201|    198|    ++begin;
  202|    198|  }
  203|  7.34k|  int dropped_digits = 0;
  204|       |  // Discard any trailing zeroes.  These may or may not be after the decimal
  205|       |  // point.
  206|  1.56M|  while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (206:10): [True: 1.56M, False: 0]
  |  Branch (206:25): [True: 1.55M, False: 7.34k]
  ------------------
  207|  1.55M|    --end;
  208|  1.55M|    ++dropped_digits;
  209|  1.55M|  }
  210|  7.34k|  if (begin < end && *std::prev(end) == '.') {
  ------------------
  |  Branch (210:7): [True: 7.34k, False: 0]
  |  Branch (210:22): [True: 287, False: 7.06k]
  ------------------
  211|       |    // If the string ends in '.', either before or after dropping zeroes, then
  212|       |    // drop the decimal point and look for more digits to drop.
  213|    287|    dropped_digits = 0;
  214|    287|    --end;
  215|    493|    while (begin < end && *std::prev(end) == '0') {
  ------------------
  |  Branch (215:12): [True: 493, False: 0]
  |  Branch (215:27): [True: 206, False: 287]
  ------------------
  216|    206|      --end;
  217|    206|      ++dropped_digits;
  218|    206|    }
  219|  7.06k|  } else if (dropped_digits) {
  ------------------
  |  Branch (219:14): [True: 448, False: 6.61k]
  ------------------
  220|       |    // We dropped digits, and aren't sure if they're before or after the decimal
  221|       |    // point.  Figure that out now.
  222|    448|    const char* dp = std::find(begin, end, '.');
  223|    448|    if (dp != end) {
  ------------------
  |  Branch (223:9): [True: 238, False: 210]
  ------------------
  224|       |      // The dropped trailing digits were after the decimal point, so don't
  225|       |      // count them.
  226|    238|      dropped_digits = 0;
  227|    238|    }
  228|    448|  }
  229|       |  // Any non-fraction digits we dropped need to be accounted for in our exponent
  230|       |  // adjustment.
  231|  7.34k|  int exponent_adjust = dropped_digits;
  232|       |
  233|  7.34k|  uint32_t queued = 0;
  234|  7.34k|  int digits_queued = 0;
  235|  1.82M|  for (; begin != end && significant_digits > 0; ++begin) {
  ------------------
  |  Branch (235:10): [True: 1.81M, False: 6.59k]
  |  Branch (235:26): [True: 1.81M, False: 750]
  ------------------
  236|  1.81M|    if (*begin == '.') {
  ------------------
  |  Branch (236:9): [True: 5.20k, False: 1.80M]
  ------------------
  237|  5.20k|      after_decimal_point = true;
  238|  5.20k|      continue;
  239|  5.20k|    }
  240|  1.80M|    if (after_decimal_point) {
  ------------------
  |  Branch (240:9): [True: 1.71M, False: 97.7k]
  ------------------
  241|       |      // For each fractional digit we emit in our parsed integer, adjust our
  242|       |      // decimal exponent to compensate.
  243|  1.71M|      --exponent_adjust;
  244|  1.71M|    }
  245|  1.80M|    char digit = (*begin - '0');
  246|  1.80M|    --significant_digits;
  247|  1.80M|    if (significant_digits == 0 && std::next(begin) != end &&
  ------------------
  |  Branch (247:9): [True: 949, False: 1.80M]
  |  Branch (247:36): [True: 750, False: 199]
  ------------------
  248|    750|        (digit == 0 || digit == 5)) {
  ------------------
  |  Branch (248:10): [True: 213, False: 537]
  |  Branch (248:24): [True: 286, False: 251]
  ------------------
  249|       |      // If this is the very last significant digit, but insignificant digits
  250|       |      // remain, we know that the last of those remaining significant digits is
  251|       |      // nonzero.  (If it wasn't, we would have stripped it before we got here.)
  252|       |      // So if this final digit is a 0 or 5, adjust it upward by 1.
  253|       |      //
  254|       |      // This adjustment is what allows incredibly large mantissas ending in
  255|       |      // 500000...000000000001 to correctly round up, rather than to nearest.
  256|    499|      ++digit;
  257|    499|    }
  258|  1.80M|    queued = 10 * queued + static_cast<uint32_t>(digit);
  259|  1.80M|    ++digits_queued;
  260|  1.80M|    if (digits_queued == kMaxSmallPowerOfTen) {
  ------------------
  |  Branch (260:9): [True: 198k, False: 1.61M]
  ------------------
  261|   198k|      MultiplyBy(kTenToNth[kMaxSmallPowerOfTen]);
  262|   198k|      AddWithCarry(0, queued);
  263|   198k|      queued = digits_queued = 0;
  264|   198k|    }
  265|  1.80M|  }
  266|       |  // Encode any remaining digits.
  267|  7.34k|  if (digits_queued) {
  ------------------
  |  Branch (267:7): [True: 6.04k, False: 1.30k]
  ------------------
  268|  6.04k|    MultiplyBy(kTenToNth[digits_queued]);
  269|  6.04k|    AddWithCarry(0, queued);
  270|  6.04k|  }
  271|       |
  272|       |  // If any insignificant digits remain, we will drop them.  But if we have not
  273|       |  // yet read the decimal point, then we have to adjust the exponent to account
  274|       |  // for the dropped digits.
  275|  7.34k|  if (begin < end && !after_decimal_point) {
  ------------------
  |  Branch (275:7): [True: 750, False: 6.59k]
  |  Branch (275:22): [True: 2, False: 748]
  ------------------
  276|       |    // This call to std::find will result in a pointer either to the decimal
  277|       |    // point, or to the end of our buffer if there was none.
  278|       |    //
  279|       |    // Either way, [begin, decimal_point) will contain the set of dropped digits
  280|       |    // that require an exponent adjustment.
  281|      2|    const char* decimal_point = std::find(begin, end, '.');
  282|      2|    exponent_adjust += (decimal_point - begin);
  283|      2|  }
  284|  7.34k|  return exponent_adjust;
  285|  7.34k|}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12MultiplyStepEiPKjii:
  316|   261k|                                          int other_size, int step) {
  317|   261k|  int this_i = std::min(original_size - 1, step);
  318|   261k|  int other_i = step - this_i;
  319|       |
  320|   261k|  uint64_t this_word = 0;
  321|   261k|  uint64_t carry = 0;
  322|  1.60M|  for (; this_i >= 0 && other_i < other_size; --this_i, ++other_i) {
  ------------------
  |  Branch (322:10): [True: 1.57M, False: 38.7k]
  |  Branch (322:25): [True: 1.34M, False: 222k]
  ------------------
  323|  1.34M|    uint64_t product = words_[this_i];
  324|  1.34M|    product *= other_words[other_i];
  325|  1.34M|    this_word += product;
  326|  1.34M|    carry += (this_word >> 32);
  327|  1.34M|    this_word &= 0xffffffff;
  328|  1.34M|  }
  329|   261k|  AddWithCarry(step + 1, carry);
  330|   261k|  words_[step] = this_word & 0xffffffff;
  331|   261k|  if (this_word > 0 && size_ <= step) {
  ------------------
  |  Branch (331:7): [True: 261k, False: 0]
  |  Branch (331:24): [True: 4.43k, False: 256k]
  ------------------
  332|  4.43k|    size_ = step + 1;
  333|  4.43k|  }
  334|   261k|}
charconv_bigint.cc:_ZN4absl12lts_2024011616strings_internal12_GLOBAL__N_120LargePowerOfFiveDataEi:
  152|  5.98k|const uint32_t* LargePowerOfFiveData(int i) {
  153|  5.98k|  return kLargePowersOfFive + i * (i - 1);
  154|  5.98k|}
charconv_bigint.cc:_ZN4absl12lts_2024011616strings_internal12_GLOBAL__N_120LargePowerOfFiveSizeEi:
  158|  9.65k|int LargePowerOfFiveSize(int i) { return 2 * i; }

_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EEC2Ev:
   62|  9.00k|  BigUnsigned() : size_(0), words_{} {}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE22MultiplyByFiveToTheNthEi:
  164|  9.00k|  void MultiplyByFiveToTheNth(int n) {
  165|  48.9k|    while (n >= kMaxSmallPowerOfFive) {
  ------------------
  |  Branch (165:12): [True: 39.9k, False: 9.00k]
  ------------------
  166|  39.9k|      MultiplyBy(kFiveToNth[kMaxSmallPowerOfFive]);
  167|  39.9k|      n -= kMaxSmallPowerOfFive;
  168|  39.9k|    }
  169|  9.00k|    if (n > 0) {
  ------------------
  |  Branch (169:9): [True: 6.97k, False: 2.03k]
  ------------------
  170|  6.97k|      MultiplyBy(kFiveToNth[n]);
  171|  6.97k|    }
  172|  9.00k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEj:
  130|   251k|  void MultiplyBy(uint32_t v) {
  131|   251k|    if (size_ == 0 || v == 1) {
  ------------------
  |  Branch (131:9): [True: 7.39k, False: 244k]
  |  Branch (131:23): [True: 0, False: 244k]
  ------------------
  132|  7.39k|      return;
  133|  7.39k|    }
  134|   244k|    if (v == 0) {
  ------------------
  |  Branch (134:9): [True: 0, False: 244k]
  ------------------
  135|      0|      SetToZero();
  136|      0|      return;
  137|      0|    }
  138|   244k|    const uint64_t factor = v;
  139|   244k|    uint64_t window = 0;
  140|  7.68M|    for (int i = 0; i < size_; ++i) {
  ------------------
  |  Branch (140:21): [True: 7.44M, False: 244k]
  ------------------
  141|  7.44M|      window += factor * words_[i];
  142|  7.44M|      words_[i] = window & 0xffffffff;
  143|  7.44M|      window >>= 32;
  144|  7.44M|    }
  145|       |    // If carry bits remain and there's space for them, grow size_.
  146|   244k|    if (window && size_ < max_words) {
  ------------------
  |  Branch (146:9): [True: 224k, False: 20.4k]
  |  Branch (146:19): [True: 224k, False: 0]
  ------------------
  147|   224k|      words_[size_] = window & 0xffffffff;
  148|   224k|      ++size_;
  149|   224k|    }
  150|   244k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE9SetToZeroEv:
  199|  16.3k|  void SetToZero() {
  200|  16.3k|    std::fill_n(words_, size_, 0u);
  201|  16.3k|    size_ = 0;
  202|  16.3k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EEC2Em:
   64|  9.00k|      : size_((v >> 32) ? 2 : v ? 1 : 0),
  ------------------
  |  Branch (64:15): [True: 3.05k, False: 5.94k]
  |  Branch (64:31): [True: 5.94k, False: 0]
  ------------------
   65|  9.00k|        words_{static_cast<uint32_t>(v & 0xffffffffu),
   66|  9.00k|               static_cast<uint32_t>(v >> 32)} {}
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE9ShiftLeftEi:
  102|  9.00k|  void ShiftLeft(int count) {
  103|  9.00k|    if (count > 0) {
  ------------------
  |  Branch (103:9): [True: 8.66k, False: 340]
  ------------------
  104|  8.66k|      const int word_shift = count / 32;
  105|  8.66k|      if (word_shift >= max_words) {
  ------------------
  |  Branch (105:11): [True: 0, False: 8.66k]
  ------------------
  106|      0|        SetToZero();
  107|      0|        return;
  108|      0|      }
  109|  8.66k|      size_ = (std::min)(size_ + word_shift, max_words);
  110|  8.66k|      count %= 32;
  111|  8.66k|      if (count == 0) {
  ------------------
  |  Branch (111:11): [True: 397, False: 8.27k]
  ------------------
  112|    397|        std::copy_backward(words_, words_ + size_ - word_shift, words_ + size_);
  113|  8.27k|      } else {
  114|   148k|        for (int i = (std::min)(size_, max_words - 1); i > word_shift; --i) {
  ------------------
  |  Branch (114:56): [True: 140k, False: 8.27k]
  ------------------
  115|   140k|          words_[i] = (words_[i - word_shift] << count) |
  116|   140k|                      (words_[i - word_shift - 1] >> (32 - count));
  117|   140k|        }
  118|  8.27k|        words_[word_shift] = words_[0] << count;
  119|       |        // Grow size_ if necessary.
  120|  8.27k|        if (size_ < max_words && words_[size_]) {
  ------------------
  |  Branch (120:13): [True: 8.27k, False: 0]
  |  Branch (120:34): [True: 4.03k, False: 4.23k]
  ------------------
  121|  4.03k|          ++size_;
  122|  4.03k|        }
  123|  8.27k|      }
  124|  8.66k|      std::fill_n(words_, word_shift, 0u);
  125|  8.66k|    }
  126|  9.00k|  }
_ZN4absl12lts_2024011616strings_internal7CompareILi84ELi84EEEiRKNS1_11BigUnsignedIXT_EEERKNS3_IXT0_EEE:
  353|  9.00k|int Compare(const BigUnsigned<N>& lhs, const BigUnsigned<M>& rhs) {
  354|  9.00k|  int limit = (std::max)(lhs.size(), rhs.size());
  355|  25.2k|  for (int i = limit - 1; i >= 0; --i) {
  ------------------
  |  Branch (355:27): [True: 24.3k, False: 900]
  ------------------
  356|  24.3k|    const uint32_t lhs_word = lhs.GetWord(i);
  357|  24.3k|    const uint32_t rhs_word = rhs.GetWord(i);
  358|  24.3k|    if (lhs_word < rhs_word) {
  ------------------
  |  Branch (358:9): [True: 6.17k, False: 18.1k]
  ------------------
  359|  6.17k|      return -1;
  360|  18.1k|    } else if (lhs_word > rhs_word) {
  ------------------
  |  Branch (360:16): [True: 1.93k, False: 16.2k]
  ------------------
  361|  1.93k|      return 1;
  362|  1.93k|    }
  363|  24.3k|  }
  364|    900|  return 0;
  365|  9.00k|}
_ZNK4absl12lts_2024011616strings_internal11BigUnsignedILi84EE4sizeEv:
  217|  18.0k|  int size() const { return size_; }
_ZNK4absl12lts_2024011616strings_internal11BigUnsignedILi84EE7GetWordEi:
  206|  48.6k|  uint32_t GetWord(int index) const {
  207|  48.6k|    if (index < 0 || index >= size_) {
  ------------------
  |  Branch (207:9): [True: 0, False: 48.6k]
  |  Branch (207:22): [True: 194, False: 48.5k]
  ------------------
  208|    194|      return 0;
  209|    194|    }
  210|  48.5k|    return words_[index];
  211|  48.6k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEm:
  152|  5.94k|  void MultiplyBy(uint64_t v) {
  153|  5.94k|    uint32_t words[2];
  154|  5.94k|    words[0] = static_cast<uint32_t>(v);
  155|  5.94k|    words[1] = static_cast<uint32_t>(v >> 32);
  156|  5.94k|    if (words[1] == 0) {
  ------------------
  |  Branch (156:9): [True: 0, False: 5.94k]
  ------------------
  157|      0|      MultiplyBy(words[0]);
  158|  5.94k|    } else {
  159|  5.94k|      MultiplyBy(2, words);
  160|  5.94k|    }
  161|  5.94k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE10MultiplyByEiPKj:
  270|  8.27k|  void MultiplyBy(int other_size, const uint32_t* other_words) {
  271|  8.27k|    const int original_size = size_;
  272|  8.27k|    const int first_step =
  273|  8.27k|        (std::min)(original_size + other_size - 2, max_words - 1);
  274|   269k|    for (int step = first_step; step >= 0; --step) {
  ------------------
  |  Branch (274:33): [True: 261k, False: 8.27k]
  ------------------
  275|   261k|      MultiplyStep(original_size, other_words, other_size, step);
  276|   261k|    }
  277|  8.27k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12AddWithCarryEij:
  280|   338k|  void AddWithCarry(int index, uint32_t value) {
  281|   338k|    if (value) {
  ------------------
  |  Branch (281:9): [True: 337k, False: 1.47k]
  ------------------
  282|   699k|      while (index < max_words && value > 0) {
  ------------------
  |  Branch (282:14): [True: 699k, False: 0]
  |  Branch (282:35): [True: 362k, False: 337k]
  ------------------
  283|   362k|        words_[index] += value;
  284|       |        // carry if we overflowed in this word:
  285|   362k|        if (value > words_[index]) {
  ------------------
  |  Branch (285:13): [True: 24.6k, False: 337k]
  ------------------
  286|  24.6k|          value = 1;
  287|  24.6k|          ++index;
  288|   337k|        } else {
  289|   337k|          value = 0;
  290|   337k|        }
  291|   362k|      }
  292|   337k|      size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  293|   337k|    }
  294|   338k|  }
_ZN4absl12lts_2024011616strings_internal11BigUnsignedILi84EE12AddWithCarryEim:
  296|   261k|  void AddWithCarry(int index, uint64_t value) {
  297|   261k|    if (value && index < max_words) {
  ------------------
  |  Branch (297:9): [True: 256k, False: 4.67k]
  |  Branch (297:18): [True: 256k, False: 0]
  ------------------
  298|   256k|      uint32_t high = value >> 32;
  299|   256k|      uint32_t low = value & 0xffffffff;
  300|   256k|      words_[index] += low;
  301|   256k|      if (words_[index] < low) {
  ------------------
  |  Branch (301:11): [True: 93.3k, False: 163k]
  ------------------
  302|  93.3k|        ++high;
  303|  93.3k|        if (high == 0) {
  ------------------
  |  Branch (303:13): [True: 0, False: 93.3k]
  ------------------
  304|       |          // Carry from the low word caused our high word to overflow.
  305|       |          // Short circuit here to do the right thing.
  306|      0|          AddWithCarry(index + 2, static_cast<uint32_t>(1));
  307|      0|          return;
  308|      0|        }
  309|  93.3k|      }
  310|   256k|      if (high > 0) {
  ------------------
  |  Branch (310:11): [True: 133k, False: 122k]
  ------------------
  311|   133k|        AddWithCarry(index + 1, high);
  312|   133k|      } else {
  313|       |        // Normally 32-bit AddWithCarry() sets size_, but since we don't call
  314|       |        // it when `high` is 0, do it ourselves here.
  315|   122k|        size_ = (std::min)(max_words, (std::max)(index + 1, size_));
  316|   122k|      }
  317|   256k|    }
  318|   261k|  }

_ZN4absl12lts_2024011616strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  19.4k|                                         chars_format format_flags) {
  357|  19.4k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  19.4k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 17, False: 19.4k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  19.4k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 1.09k, False: 18.3k]
  ------------------
  364|  1.09k|    return result;
  365|  1.09k|  }
  366|       |
  367|  18.3k|  const char* const mantissa_begin = begin;
  368|  20.8k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 19.7k, False: 1.10k]
  |  Branch (368:25): [True: 2.50k, False: 17.2k]
  ------------------
  369|  2.50k|    ++begin;  // skip leading zeros
  370|  2.50k|  }
  371|  18.3k|  uint64_t mantissa = 0;
  372|       |
  373|  18.3k|  int exponent_adjustment = 0;
  374|  18.3k|  bool mantissa_is_inexact = false;
  375|  18.3k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  18.3k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  18.3k|  begin += pre_decimal_digits;
  378|  18.3k|  int digits_left;
  379|  18.3k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 18.3k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  18.3k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 4.27k, False: 14.0k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|  4.27k|    exponent_adjustment =
  386|  4.27k|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|  4.27k|    digits_left = 0;
  388|  14.0k|  } else {
  389|  14.0k|    digits_left =
  390|  14.0k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  14.0k|  }
  392|  18.3k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 15.2k, False: 3.15k]
  |  Branch (392:22): [True: 8.14k, False: 7.05k]
  ------------------
  393|  8.14k|    ++begin;
  394|  8.14k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 3.81k, False: 4.33k]
  ------------------
  395|       |      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
  396|       |      // have to adjust the exponent to reflect the changed place value.
  397|  3.81k|      const char* begin_zeros = begin;
  398|  4.71k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 4.17k, False: 546]
  |  Branch (398:29): [True: 904, False: 3.26k]
  ------------------
  399|    904|        ++begin;
  400|    904|      }
  401|  3.81k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  3.81k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 3.81k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  3.81k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  3.81k|    }
  408|  8.14k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  8.14k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  8.14k|    begin += post_decimal_digits;
  411|       |
  412|       |    // Since `mantissa` is an integer, each significant digit we read after
  413|       |    // the decimal point requires an adjustment to the exponent. "1.23e0" will
  414|       |    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
  415|       |    // "123e-2").
  416|  8.14k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 8.14k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  8.14k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 5.25k, False: 2.88k]
  ------------------
  420|  5.25k|      exponent_adjustment -= digits_left;
  421|  5.25k|    } else {
  422|  2.88k|      exponent_adjustment -= post_decimal_digits;
  423|  2.88k|    }
  424|  8.14k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  18.3k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 111, False: 18.2k]
  ------------------
  427|    111|    return result;
  428|    111|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  18.2k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 5.69k, False: 12.5k]
  |  Branch (430:38): [True: 21, False: 5.67k]
  ------------------
  431|     21|    return result;
  432|     21|  }
  433|       |
  434|  18.2k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 8.29k, False: 9.93k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|  8.29k|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 8.29k, Folded]
  ------------------
  437|       |      // If we truncated significant decimal digits, store the full range of the
  438|       |      // mantissa for future big integer math for exact rounding.
  439|  8.29k|      result.subrange_begin = mantissa_begin;
  440|  8.29k|      result.subrange_end = begin;
  441|  8.29k|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [Folded, False: 0]
  ------------------
  442|       |      // If we truncated hex digits, reflect this fact by setting the low
  443|       |      // ("sticky") bit.  This allows for correct rounding in all cases.
  444|      0|      mantissa |= 1;
  445|      0|    }
  446|  8.29k|  }
  447|  18.2k|  result.mantissa = mantissa;
  448|       |
  449|  18.2k|  const char* const exponent_begin = begin;
  450|  18.2k|  result.literal_exponent = 0;
  451|  18.2k|  bool found_exponent = false;
  452|  18.2k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 18.2k, False: 0]
  |  Branch (452:38): [True: 8.29k, False: 9.92k]
  ------------------
  453|  8.29k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 8.19k, False: 108]
  ------------------
  454|  8.19k|    bool negative_exponent = false;
  455|  8.19k|    ++begin;
  456|  8.19k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 8.17k, False: 14]
  |  Branch (456:24): [True: 2.14k, False: 6.03k]
  ------------------
  457|  2.14k|      negative_exponent = true;
  458|  2.14k|      ++begin;
  459|  6.05k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 6.03k, False: 14]
  |  Branch (459:31): [True: 974, False: 5.06k]
  ------------------
  460|    974|      ++begin;
  461|    974|    }
  462|  8.19k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  8.19k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  8.19k|                               &result.literal_exponent, nullptr);
  466|  8.19k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 38, False: 8.15k]
  ------------------
  467|       |      // there were no digits where we expected an exponent.  We failed to read
  468|       |      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
  469|     38|      found_exponent = false;
  470|     38|      begin = exponent_begin;
  471|  8.15k|    } else {
  472|  8.15k|      found_exponent = true;
  473|  8.15k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 2.13k, False: 6.01k]
  ------------------
  474|  2.13k|        result.literal_exponent = -result.literal_exponent;
  475|  2.13k|      }
  476|  8.15k|    }
  477|  8.19k|  }
  478|       |
  479|  18.2k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 10.0k, False: 8.15k]
  |  Branch (479:26): [True: 0, False: 10.0k]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  18.2k|  result.type = strings_internal::FloatType::kNumber;
  487|  18.2k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 15.9k, False: 2.31k]
  ------------------
  488|  15.9k|    result.exponent = result.literal_exponent +
  489|  15.9k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  15.9k|  } else {
  491|  2.31k|    result.exponent = 0;
  492|  2.31k|  }
  493|  18.2k|  result.end = begin;
  494|  18.2k|  return result;
  495|  18.2k|}
_ZN4absl12lts_2024011616strings_internal10ParseFloatILi16EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  5.13k|                                         chars_format format_flags) {
  357|  5.13k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  5.13k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 13, False: 5.11k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  5.11k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 1, False: 5.11k]
  ------------------
  364|      1|    return result;
  365|      1|  }
  366|       |
  367|  5.11k|  const char* const mantissa_begin = begin;
  368|  6.19k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 5.89k, False: 296]
  |  Branch (368:25): [True: 1.07k, False: 4.82k]
  ------------------
  369|  1.07k|    ++begin;  // skip leading zeros
  370|  1.07k|  }
  371|  5.11k|  uint64_t mantissa = 0;
  372|       |
  373|  5.11k|  int exponent_adjustment = 0;
  374|  5.11k|  bool mantissa_is_inexact = false;
  375|  5.11k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  5.11k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  5.11k|  begin += pre_decimal_digits;
  378|  5.11k|  int digits_left;
  379|  5.11k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 5.11k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  5.11k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 391, False: 4.72k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|    391|    exponent_adjustment =
  386|    391|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|    391|    digits_left = 0;
  388|  4.72k|  } else {
  389|  4.72k|    digits_left =
  390|  4.72k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  4.72k|  }
  392|  5.11k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 3.60k, False: 1.51k]
  |  Branch (392:22): [True: 1.52k, False: 2.08k]
  ------------------
  393|  1.52k|    ++begin;
  394|  1.52k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 894, False: 628]
  ------------------
  395|       |      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
  396|       |      // have to adjust the exponent to reflect the changed place value.
  397|    894|      const char* begin_zeros = begin;
  398|  1.35k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 942, False: 415]
  |  Branch (398:29): [True: 463, False: 479]
  ------------------
  399|    463|        ++begin;
  400|    463|      }
  401|    894|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|    894|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 894]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|    894|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|    894|    }
  408|  1.52k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  1.52k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  1.52k|    begin += post_decimal_digits;
  411|       |
  412|       |    // Since `mantissa` is an integer, each significant digit we read after
  413|       |    // the decimal point requires an adjustment to the exponent. "1.23e0" will
  414|       |    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
  415|       |    // "123e-2").
  416|  1.52k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 1.52k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  1.52k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 314, False: 1.20k]
  ------------------
  420|    314|      exponent_adjustment -= digits_left;
  421|  1.20k|    } else {
  422|  1.20k|      exponent_adjustment -= post_decimal_digits;
  423|  1.20k|    }
  424|  1.52k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  5.11k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 16, False: 5.10k]
  ------------------
  427|     16|    return result;
  428|     16|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  5.10k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 2.62k, False: 2.47k]
  |  Branch (430:38): [True: 20, False: 2.60k]
  ------------------
  431|     20|    return result;
  432|     20|  }
  433|       |
  434|  5.08k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 544, False: 4.53k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|    544|    if (base == 10) {
  ------------------
  |  Branch (436:9): [Folded, False: 544]
  ------------------
  437|       |      // If we truncated significant decimal digits, store the full range of the
  438|       |      // mantissa for future big integer math for exact rounding.
  439|      0|      result.subrange_begin = mantissa_begin;
  440|      0|      result.subrange_end = begin;
  441|    544|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [True: 544, Folded]
  ------------------
  442|       |      // If we truncated hex digits, reflect this fact by setting the low
  443|       |      // ("sticky") bit.  This allows for correct rounding in all cases.
  444|    544|      mantissa |= 1;
  445|    544|    }
  446|    544|  }
  447|  5.08k|  result.mantissa = mantissa;
  448|       |
  449|  5.08k|  const char* const exponent_begin = begin;
  450|  5.08k|  result.literal_exponent = 0;
  451|  5.08k|  bool found_exponent = false;
  452|  5.08k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 5.08k, False: 0]
  |  Branch (452:38): [True: 2.27k, False: 2.80k]
  ------------------
  453|  2.27k|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 2.23k, False: 36]
  ------------------
  454|  2.23k|    bool negative_exponent = false;
  455|  2.23k|    ++begin;
  456|  2.23k|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 2.22k, False: 14]
  |  Branch (456:24): [True: 1.09k, False: 1.12k]
  ------------------
  457|  1.09k|      negative_exponent = true;
  458|  1.09k|      ++begin;
  459|  1.13k|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 1.12k, False: 14]
  |  Branch (459:31): [True: 194, False: 930]
  ------------------
  460|    194|      ++begin;
  461|    194|    }
  462|  2.23k|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|  2.23k|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|  2.23k|                               &result.literal_exponent, nullptr);
  466|  2.23k|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 31, False: 2.20k]
  ------------------
  467|       |      // there were no digits where we expected an exponent.  We failed to read
  468|       |      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
  469|     31|      found_exponent = false;
  470|     31|      begin = exponent_begin;
  471|  2.20k|    } else {
  472|  2.20k|      found_exponent = true;
  473|  2.20k|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 1.09k, False: 1.10k]
  ------------------
  474|  1.09k|        result.literal_exponent = -result.literal_exponent;
  475|  1.09k|      }
  476|  2.20k|    }
  477|  2.23k|  }
  478|       |
  479|  5.08k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 2.87k, False: 2.20k]
  |  Branch (479:26): [True: 0, False: 2.87k]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  5.08k|  result.type = strings_internal::FloatType::kNumber;
  487|  5.08k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 4.01k, False: 1.07k]
  ------------------
  488|  4.01k|    result.exponent = result.literal_exponent +
  489|  4.01k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  4.01k|  } else {
  491|  1.07k|    result.exponent = 0;
  492|  1.07k|  }
  493|  5.08k|  result.end = begin;
  494|  5.08k|  return result;
  495|  5.08k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  23.3k|bool AllowExponent(chars_format flags) {
  123|  23.3k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  23.3k|  bool scientific =
  125|  23.3k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  23.3k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 23.3k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  23.3k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  12.9k|bool RequireExponent(chars_format flags) {
  131|  12.9k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  12.9k|  bool scientific =
  133|  12.9k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  12.9k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 12.9k, False: 0]
  |  Branch (134:24): [True: 0, False: 12.9k]
  ------------------
  135|  12.9k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119IsExponentCharacterILi10EEEbc:
  201|  8.29k|bool IsExponentCharacter<10>(char ch) {
  202|  8.29k|  return ch == 'e' || ch == 'E';
  ------------------
  |  Branch (202:10): [True: 6.83k, False: 1.46k]
  |  Branch (202:23): [True: 1.35k, False: 108]
  ------------------
  203|  8.29k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_119IsExponentCharacterILi16EEEbc:
  206|  2.27k|bool IsExponentCharacter<16>(char ch) {
  207|  2.27k|  return ch == 'p' || ch == 'P';
  ------------------
  |  Branch (207:10): [True: 1.43k, False: 838]
  |  Branch (207:23): [True: 802, False: 36]
  ------------------
  208|  2.27k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  55.0k|constexpr int MantissaDigitsMax<10>() {
  212|  55.0k|  return kDecimalMantissaDigitsMax;
  213|  55.0k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_117MantissaDigitsMaxILi16EEEiv:
  215|  15.3k|constexpr int MantissaDigitsMax<16>() {
  216|  15.3k|  return kHexadecimalMantissaDigitsMax;
  217|  15.3k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  30.3k|constexpr int DigitLimit<10>() {
  221|  30.3k|  return kDecimalDigitLimit;
  222|  30.3k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_110DigitLimitILi16EEEiv:
  224|  7.53k|constexpr int DigitLimit<16>() {
  225|  7.53k|  return kHexadecimalDigitLimit;
  226|  7.53k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  15.9k|constexpr int DigitMagnitude<10>() {
  230|  15.9k|  return 1;
  231|  15.9k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DigitMagnitudeILi16EEEiv:
  233|  4.01k|constexpr int DigitMagnitude<16>() {
  234|  4.01k|  return 4;
  235|  4.01k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  24.5k|                        strings_internal::ParsedFloat* out) {
  299|  24.5k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 4.80k, False: 19.7k]
  ------------------
  300|  4.80k|    return false;
  301|  4.80k|  }
  302|  19.7k|  switch (*begin) {
  303|    439|    case 'i':
  ------------------
  |  Branch (303:5): [True: 439, False: 19.3k]
  ------------------
  304|    670|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 231, False: 19.5k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|    670|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 14, False: 656]
  ------------------
  308|     14|        return false;
  309|     14|      }
  310|    656|      out->type = strings_internal::FloatType::kInfinity;
  311|    656|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 47, False: 609]
  ------------------
  312|     47|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 1, False: 46]
  ------------------
  313|      1|        out->end = begin + 8;
  314|    655|      } else {
  315|    655|        out->end = begin + 3;
  316|    655|      }
  317|    656|      return true;
  318|    670|    }
  319|    198|    case 'n':
  ------------------
  |  Branch (319:5): [True: 198, False: 19.5k]
  ------------------
  320|    454|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 256, False: 19.5k]
  ------------------
  321|       |      // A NaN consists of the characters "nan", case insensitive, optionally
  322|       |      // followed by a parenthesized sequence of zero or more alphanumeric
  323|       |      // characters and/or underscores.
  324|    454|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 16, False: 438]
  ------------------
  325|     16|        return false;
  326|     16|      }
  327|    438|      out->type = strings_internal::FloatType::kNan;
  328|    438|      out->end = begin + 3;
  329|       |      // NaN is allowed to be followed by a parenthesized string, consisting of
  330|       |      // only the characters [a-zA-Z0-9_].  Match that if it's present.
  331|    438|      begin += 3;
  332|    438|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 2, False: 436]
  |  Branch (332:26): [True: 0, False: 2]
  ------------------
  333|      0|        const char* nan_begin = begin + 1;
  334|      0|        while (nan_begin < end && IsNanChar(*nan_begin)) {
  ------------------
  |  Branch (334:16): [True: 0, False: 0]
  |  Branch (334:35): [True: 0, False: 0]
  ------------------
  335|      0|          ++nan_begin;
  336|      0|        }
  337|      0|        if (nan_begin < end && *nan_begin == ')') {
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  |  Branch (337:32): [True: 0, False: 0]
  ------------------
  338|       |          // We found an extra NaN specifier range
  339|      0|          out->subrange_begin = begin + 1;
  340|      0|          out->subrange_end = nan_begin;
  341|      0|          out->end = nan_begin + 1;
  342|      0|        }
  343|      0|      }
  344|    438|      return true;
  345|    454|    }
  346|  18.6k|    default:
  ------------------
  |  Branch (346:5): [True: 18.6k, False: 1.12k]
  ------------------
  347|  18.6k|      return false;
  348|  19.7k|  }
  349|  19.7k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  26.5k|                  bool* dropped_nonzero_digit) {
  251|  26.5k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 26.5k, Folded]
  ------------------
  252|  26.5k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  26.5k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  26.5k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  26.5k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 22.1k, False: 4.33k]
  |  Branch (261:19): [True: 20.5k, False: 1.64k]
  |  Branch (261:35): [True: 0, False: 20.5k]
  ------------------
  262|       |
  263|  26.5k|  T accumulator = *out;
  264|  26.5k|  const char* significant_digits_end =
  265|  26.5k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 13.7k, False: 12.7k]
  ------------------
  266|   215k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 201k, False: 14.6k]
  |  Branch (266:44): [True: 189k, False: 11.8k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|   189k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|   189k|    assert(accumulator * base >= accumulator);
  271|   189k|    accumulator *= base;
  272|   189k|    assert(accumulator + digit >= accumulator);
  273|   189k|    accumulator += digit;
  274|   189k|    ++begin;
  275|   189k|  }
  276|  26.5k|  bool dropped_nonzero = false;
  277|  15.1M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 15.1M, False: 9.93k]
  |  Branch (277:25): [True: 15.1M, False: 16.5k]
  ------------------
  278|  15.1M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 15.1M, False: 13.9k]
  |  Branch (278:42): [True: 9.50k, False: 4.44k]
  ------------------
  279|  15.1M|    ++begin;
  280|  15.1M|  }
  281|  26.5k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 9.50k, False: 16.9k]
  |  Branch (281:26): [True: 9.50k, False: 0]
  ------------------
  282|  9.50k|    *dropped_nonzero_digit = true;
  283|  9.50k|  }
  284|  26.5k|  *out = accumulator;
  285|  26.5k|  return static_cast<int>(begin - original_begin);
  286|  26.5k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  28.4M|bool IsDigit<10>(char ch) {
  184|  28.4M|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 28.4M, False: 14.8k]
  |  Branch (184:23): [True: 28.4M, False: 13.6k]
  ------------------
  185|  28.4M|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17ToDigitILi10EEEjc:
  192|   213k|unsigned ToDigit<10>(char ch) {
  193|   213k|  return static_cast<unsigned>(ch - '0');
  194|   213k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi10EiEEiPKcS4_iPT0_Pb:
  250|  10.4k|                  bool* dropped_nonzero_digit) {
  251|  10.4k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 10.4k, Folded]
  ------------------
  252|  10.4k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  10.4k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  10.4k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  11.9k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 11.9k, False: 0]
  |  Branch (261:19): [True: 10.5k, False: 1.33k]
  |  Branch (261:35): [True: 1.50k, False: 9.09k]
  ------------------
  262|       |
  263|  10.4k|  T accumulator = *out;
  264|  10.4k|  const char* significant_digits_end =
  265|  10.4k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 296, False: 10.1k]
  ------------------
  266|  34.6k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 24.2k, False: 10.3k]
  |  Branch (266:44): [True: 24.2k, False: 38]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  24.2k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  24.2k|    assert(accumulator * base >= accumulator);
  271|  24.2k|    accumulator *= base;
  272|  24.2k|    assert(accumulator + digit >= accumulator);
  273|  24.2k|    accumulator += digit;
  274|  24.2k|    ++begin;
  275|  24.2k|  }
  276|  10.4k|  bool dropped_nonzero = false;
  277|  13.0M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 13.0M, False: 10.3k]
  |  Branch (277:25): [True: 13.0M, False: 47]
  ------------------
  278|  13.0M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 13.0M, False: 324]
  |  Branch (278:42): [True: 271, False: 53]
  ------------------
  279|  13.0M|    ++begin;
  280|  13.0M|  }
  281|  10.4k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 271, False: 10.1k]
  |  Branch (281:26): [True: 0, False: 271]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  10.4k|  *out = accumulator;
  285|  10.4k|  return static_cast<int>(begin - original_begin);
  286|  10.4k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_113ConsumeDigitsILi16EmEEiPKcS4_iPT0_Pb:
  250|  6.63k|                  bool* dropped_nonzero_digit) {
  251|  6.63k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [Folded, False: 6.63k]
  ------------------
  252|      0|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  6.63k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [True: 6.63k, Folded]
  ------------------
  254|  6.63k|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|  6.63k|  }
  256|  6.63k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  6.63k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 6.01k, False: 628]
  |  Branch (261:19): [True: 5.30k, False: 711]
  |  Branch (261:35): [True: 0, False: 5.30k]
  ------------------
  262|       |
  263|  6.63k|  T accumulator = *out;
  264|  6.63k|  const char* significant_digits_end =
  265|  6.63k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 901, False: 5.73k]
  ------------------
  266|  27.4k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 24.4k, False: 3.03k]
  |  Branch (266:44): [True: 20.8k, False: 3.60k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  20.8k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  20.8k|    assert(accumulator * base >= accumulator);
  271|  20.8k|    accumulator *= base;
  272|  20.8k|    assert(accumulator + digit >= accumulator);
  273|  20.8k|    accumulator += digit;
  274|  20.8k|    ++begin;
  275|  20.8k|  }
  276|  6.63k|  bool dropped_nonzero = false;
  277|  14.2M|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 14.2M, False: 2.81k]
  |  Branch (277:25): [True: 14.2M, False: 3.82k]
  ------------------
  278|  14.2M|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 14.2M, False: 1.08k]
  |  Branch (278:42): [True: 679, False: 403]
  ------------------
  279|  14.2M|    ++begin;
  280|  14.2M|  }
  281|  6.63k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 679, False: 5.96k]
  |  Branch (281:26): [True: 679, False: 0]
  ------------------
  282|    679|    *dropped_nonzero_digit = true;
  283|    679|  }
  284|  6.63k|  *out = accumulator;
  285|  6.63k|  return static_cast<int>(begin - original_begin);
  286|  6.63k|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17IsDigitILi16EEEbc:
  187|  14.2M|bool IsDigit<16>(char ch) {
  188|  14.2M|  return kAsciiToInt[static_cast<unsigned char>(ch)] >= 0;
  189|  14.2M|}
charconv_parse.cc:_ZN4absl12lts_2024011612_GLOBAL__N_17ToDigitILi16EEEjc:
  196|  20.8k|unsigned ToDigit<16>(char ch) {
  197|  20.8k|  return static_cast<unsigned>(kAsciiToInt[static_cast<unsigned char>(ch)]);
  198|  20.8k|}

_ZN4absl12lts_2024011616strings_internal33CalculateBase64EscapedLenInternalEmb:
   35|      2|size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
   36|       |  // Base64 encodes three bytes of input at a time. If the input is not
   37|       |  // divisible by three, we pad as appropriate.
   38|       |  //
   39|       |  // Base64 encodes each three bytes of input into four bytes of output.
   40|      2|  size_t len = (input_len / 3) * 4;
   41|       |
   42|       |  // Since all base 64 input is an integral number of octets, only the following
   43|       |  // cases can arise:
   44|      2|  if (input_len % 3 == 0) {
  ------------------
  |  Branch (44:7): [True: 0, False: 2]
  ------------------
   45|       |    // (from https://tools.ietf.org/html/rfc3548)
   46|       |    // (1) the final quantum of encoding input is an integral multiple of 24
   47|       |    // bits; here, the final unit of encoded output will be an integral
   48|       |    // multiple of 4 characters with no "=" padding,
   49|      2|  } else if (input_len % 3 == 1) {
  ------------------
  |  Branch (49:14): [True: 0, False: 2]
  ------------------
   50|       |    // (from https://tools.ietf.org/html/rfc3548)
   51|       |    // (2) the final quantum of encoding input is exactly 8 bits; here, the
   52|       |    // final unit of encoded output will be two characters followed by two
   53|       |    // "=" padding characters, or
   54|      0|    len += 2;
   55|      0|    if (do_padding) {
  ------------------
  |  Branch (55:9): [True: 0, False: 0]
  ------------------
   56|      0|      len += 2;
   57|      0|    }
   58|      2|  } else {  // (input_len % 3 == 2)
   59|       |    // (from https://tools.ietf.org/html/rfc3548)
   60|       |    // (3) the final quantum of encoding input is exactly 16 bits; here, the
   61|       |    // final unit of encoded output will be three characters followed by one
   62|       |    // "=" padding character.
   63|      2|    len += 3;
   64|      2|    if (do_padding) {
  ------------------
  |  Branch (64:9): [True: 0, False: 2]
  ------------------
   65|      0|      len += 1;
   66|      0|    }
   67|      2|  }
   68|       |
   69|       |  assert(len >= input_len);  // make sure we didn't overflow
   70|      2|  return len;
   71|      2|}
_ZN4absl12lts_2024011616strings_internal20Base64EscapeInternalEPKhmPcmPKcb:
   90|      2|                            bool do_padding) {
   91|      2|  static const char kPad64 = '=';
   92|       |
   93|      2|  if (szsrc * 4 > szdest * 3) return 0;
  ------------------
  |  Branch (93:7): [True: 0, False: 2]
  ------------------
   94|       |
   95|      2|  char* cur_dest = dest;
   96|      2|  const unsigned char* cur_src = src;
   97|       |
   98|      2|  char* const limit_dest = dest + szdest;
   99|      2|  const unsigned char* const limit_src = src + szsrc;
  100|       |
  101|       |  // (from https://tools.ietf.org/html/rfc3548)
  102|       |  // Special processing is performed if fewer than 24 bits are available
  103|       |  // at the end of the data being encoded.  A full encoding quantum is
  104|       |  // always completed at the end of a quantity.  When fewer than 24 input
  105|       |  // bits are available in an input group, zero bits are added (on the
  106|       |  // right) to form an integral number of 6-bit groups.
  107|       |  //
  108|       |  // If do_padding is true, padding at the end of the data is performed. This
  109|       |  // output padding uses the '=' character.
  110|       |
  111|       |  // Three bytes of data encodes to four characters of cyphertext.
  112|       |  // So we can pump through three-byte chunks atomically.
  113|      2|  if (szsrc >= 3) {                    // "limit_src - 3" is UB if szsrc < 3.
  ------------------
  |  Branch (113:7): [True: 2, False: 0]
  ------------------
  114|     22|    while (cur_src < limit_src - 3) {  // While we have >= 32 bits.
  ------------------
  |  Branch (114:12): [True: 20, False: 2]
  ------------------
  115|     20|      uint32_t in = absl::big_endian::Load32(cur_src) >> 8;
  116|       |
  117|     20|      cur_dest[0] = base64[in >> 18];
  118|     20|      in &= 0x3FFFF;
  119|     20|      cur_dest[1] = base64[in >> 12];
  120|     20|      in &= 0xFFF;
  121|     20|      cur_dest[2] = base64[in >> 6];
  122|     20|      in &= 0x3F;
  123|     20|      cur_dest[3] = base64[in];
  124|       |
  125|     20|      cur_dest += 4;
  126|     20|      cur_src += 3;
  127|     20|    }
  128|      2|  }
  129|       |  // To save time, we didn't update szdest or szsrc in the loop.  So do it now.
  130|      2|  szdest = static_cast<size_t>(limit_dest - cur_dest);
  131|      2|  szsrc = static_cast<size_t>(limit_src - cur_src);
  132|       |
  133|       |  /* now deal with the tail (<=3 bytes) */
  134|      2|  switch (szsrc) {
  135|      0|    case 0:
  ------------------
  |  Branch (135:5): [True: 0, False: 2]
  ------------------
  136|       |      // Nothing left; nothing more to do.
  137|      0|      break;
  138|      0|    case 1: {
  ------------------
  |  Branch (138:5): [True: 0, False: 2]
  ------------------
  139|       |      // One byte left: this encodes to two characters, and (optionally)
  140|       |      // two pad characters to round out the four-character cypherblock.
  141|      0|      if (szdest < 2) return 0;
  ------------------
  |  Branch (141:11): [True: 0, False: 0]
  ------------------
  142|      0|      uint32_t in = cur_src[0];
  143|      0|      cur_dest[0] = base64[in >> 2];
  144|      0|      in &= 0x3;
  145|      0|      cur_dest[1] = base64[in << 4];
  146|      0|      cur_dest += 2;
  147|      0|      szdest -= 2;
  148|      0|      if (do_padding) {
  ------------------
  |  Branch (148:11): [True: 0, False: 0]
  ------------------
  149|      0|        if (szdest < 2) return 0;
  ------------------
  |  Branch (149:13): [True: 0, False: 0]
  ------------------
  150|      0|        cur_dest[0] = kPad64;
  151|      0|        cur_dest[1] = kPad64;
  152|      0|        cur_dest += 2;
  153|      0|        szdest -= 2;
  154|      0|      }
  155|      0|      break;
  156|      0|    }
  157|      2|    case 2: {
  ------------------
  |  Branch (157:5): [True: 2, False: 0]
  ------------------
  158|       |      // Two bytes left: this encodes to three characters, and (optionally)
  159|       |      // one pad character to round out the four-character cypherblock.
  160|      2|      if (szdest < 3) return 0;
  ------------------
  |  Branch (160:11): [True: 0, False: 2]
  ------------------
  161|      2|      uint32_t in = absl::big_endian::Load16(cur_src);
  162|      2|      cur_dest[0] = base64[in >> 10];
  163|      2|      in &= 0x3FF;
  164|      2|      cur_dest[1] = base64[in >> 4];
  165|      2|      in &= 0x00F;
  166|      2|      cur_dest[2] = base64[in << 2];
  167|      2|      cur_dest += 3;
  168|      2|      szdest -= 3;
  169|      2|      if (do_padding) {
  ------------------
  |  Branch (169:11): [True: 0, False: 2]
  ------------------
  170|      0|        if (szdest < 1) return 0;
  ------------------
  |  Branch (170:13): [True: 0, False: 0]
  ------------------
  171|      0|        cur_dest[0] = kPad64;
  172|      0|        cur_dest += 1;
  173|      0|        szdest -= 1;
  174|      0|      }
  175|      2|      break;
  176|      2|    }
  177|      2|    case 3: {
  ------------------
  |  Branch (177:5): [True: 0, False: 2]
  ------------------
  178|       |      // Three bytes left: same as in the big loop above.  We can't do this in
  179|       |      // the loop because the loop above always reads 4 bytes, and the fourth
  180|       |      // byte is past the end of the input.
  181|      0|      if (szdest < 4) return 0;
  ------------------
  |  Branch (181:11): [True: 0, False: 0]
  ------------------
  182|      0|      uint32_t in =
  183|      0|          (uint32_t{cur_src[0]} << 16) + absl::big_endian::Load16(cur_src + 1);
  184|      0|      cur_dest[0] = base64[in >> 18];
  185|      0|      in &= 0x3FFFF;
  186|      0|      cur_dest[1] = base64[in >> 12];
  187|      0|      in &= 0xFFF;
  188|      0|      cur_dest[2] = base64[in >> 6];
  189|      0|      in &= 0x3F;
  190|      0|      cur_dest[3] = base64[in];
  191|      0|      cur_dest += 4;
  192|      0|      szdest -= 4;
  193|      0|      break;
  194|      0|    }
  195|      0|    default:
  ------------------
  |  Branch (195:5): [True: 0, False: 2]
  ------------------
  196|       |      // Should not be reached: blocks of 4 bytes are handled
  197|       |      // in the while loop before this switch statement.
  198|      0|      ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  199|      0|      break;
  200|      2|  }
  201|      2|  return static_cast<size_t>(cur_dest - dest);
  202|      2|}

_ZN4absl12lts_2024011616strings_internal20Base64EscapeInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvPKhmPT_bPKc:
   42|      2|                          bool do_padding, const char* base64_chars) {
   43|      2|  const size_t calc_escaped_size =
   44|      2|      CalculateBase64EscapedLenInternal(szsrc, do_padding);
   45|      2|  STLStringResizeUninitialized(dest, calc_escaped_size);
   46|       |
   47|      2|  const size_t escaped_len = Base64EscapeInternal(
   48|      2|      src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
   49|       |  assert(calc_escaped_size == escaped_len);
   50|      2|  dest->erase(escaped_len);
   51|      2|}

_ZN4absl12lts_2024011616strings_internal10memcasecmpEPKcS3_m:
   25|  1.17k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  1.17k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  1.17k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  3.40k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 2.31k, False: 1.09k]
  ------------------
   30|  2.31k|    unsigned char c1 = us1[i];
   31|  2.31k|    unsigned char c2 = us2[i];
   32|       |    // If bytes are the same, they will be the same when converted to lower.
   33|       |    // So we only need to convert if bytes are not equal.
   34|       |    // NOTE(b/308193381): We do not use `absl::ascii_tolower` here in order
   35|       |    // to avoid its lookup table and improve performance.
   36|  2.31k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 434, False: 1.88k]
  ------------------
   37|    434|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 415, False: 19]
  |  Branch (37:25): [True: 392, False: 23]
  ------------------
   38|    434|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 434, False: 0]
  |  Branch (38:25): [True: 0, False: 434]
  ------------------
   39|    434|      const int diff = int{c1} - int{c2};
   40|    434|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 76, False: 358]
  ------------------
   41|    434|    }
   42|  2.31k|  }
   43|  1.09k|  return 0;
   44|  1.17k|}

_ZN4absl12lts_2024011616strings_internal28STLStringResizeUninitializedINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEEvPT_m:
   67|     12|inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
   68|     12|  ResizeUninitializedTraits<string_type>::Resize(s, new_size);
   69|     12|}
_ZN4absl12lts_2024011616strings_internal25ResizeUninitializedTraitsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE6ResizeEPS9_m:
   47|     12|  static void Resize(string_type* s, size_t new_size) {
   48|     12|    s->__resize_default_init(new_size);
   49|     12|  }

_ZN4absl12lts_2024011619str_format_internal13FormatUntypedENS1_17FormatRawSinkImplENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  214|  3.73k|                   absl::Span<const FormatArgImpl> args) {
  215|  3.73k|  FormatSinkImpl sink(raw_sink);
  216|  3.73k|  using Converter = DefaultConverter;
  217|  3.73k|  return ConvertAll(format, args, Converter(&sink));
  218|  3.73k|}
_ZN4absl12lts_2024011619str_format_internal7FprintFEP8_IO_FILENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  244|  3.73k|            absl::Span<const FormatArgImpl> args) {
  245|  3.73k|  FILERawSink sink(output);
  246|  3.73k|  if (!FormatUntyped(&sink, format, args)) {
  ------------------
  |  Branch (246:7): [True: 0, False: 3.73k]
  ------------------
  247|      0|    errno = EINVAL;
  248|      0|    return -1;
  249|      0|  }
  250|  3.73k|  if (sink.error()) {
  ------------------
  |  Branch (250:7): [True: 0, False: 3.73k]
  ------------------
  251|      0|    errno = sink.error();
  252|      0|    return -1;
  253|      0|  }
  254|  3.73k|  if (sink.count() > static_cast<size_t>(std::numeric_limits<int>::max())) {
  ------------------
  |  Branch (254:7): [True: 0, False: 3.73k]
  ------------------
  255|      0|    errno = EFBIG;
  256|      0|    return -1;
  257|      0|  }
  258|  3.73k|  return static_cast<int>(sink.count());
  259|  3.73k|}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_110ArgContextC2ENS0_4SpanIKNS1_13FormatArgImplEEE:
   55|  3.73k|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS1_14FormatSinkImplE:
  154|  3.73k|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_110ConvertAllINS2_16DefaultConverterEEEbNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEET_:
  142|  3.73k|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|  3.73k|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 3.73k]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|  3.73k|  } else {
  147|  3.73k|    return ParseFormatString(format.str(),
  148|  3.73k|                             ConverterConsumer<Converter>(converter, args));
  149|  3.73k|  }
  150|  3.73k|}
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE6AppendENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  125|  3.73k|  bool Append(string_view s) {
  126|  3.73k|    converter_.Append(s);
  127|  3.73k|    return true;
  128|  3.73k|  }
bind.cc:_ZNK4absl12lts_2024011619str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  156|  3.73k|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEC2ES4_NS0_4SpanIKNS1_13FormatArgImplEEE:
  123|  3.73k|      : converter_(converter), arg_context_(pack) {}

_ZN4absl12lts_2024011619str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   56|  3.73k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl12lts_2024011619str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJEEEEERKS2_RKT_:
   73|  3.73k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  3.73k|    return s.spec_;
   75|  3.73k|  }
_ZN4absl12lts_2024011619str_format_internal18FormatSpecTemplateIJEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplITpTnNS0_23FormatConversionCharSetEJEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|  3.73k|      : Base(s) {}
_ZNK4absl12lts_2024011619str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|  3.73k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl12lts_2024011619str_format_internal21UntypedFormatSpecImpl3strEv:
   63|  3.73k|  string_view str() const {
   64|       |    assert(!has_parsed_conversion());
   65|  3.73k|    return string_view(static_cast<const char*>(data_), size_);
   66|  3.73k|  }

_ZN4absl12lts_2024011619str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   48|  3.73k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImplC2ENS1_17FormatRawSinkImplE:
   68|  3.73k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImplD2Ev:
   70|  3.73k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImpl5FlushEv:
   72|  3.73k|  void Flush() {
   73|  3.73k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|  3.73k|    pos_ = buf_;
   75|  3.73k|  }
_ZN4absl12lts_2024011619str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  3.73k|  void Append(string_view v) {
   95|  3.73k|    size_t n = v.size();
   96|  3.73k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 0, False: 3.73k]
  ------------------
   97|  3.73k|    size_ += n;
   98|  3.73k|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 3.73k]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  3.73k|    memcpy(pos_, v.data(), n);
  104|  3.73k|    pos_ += n;
  105|  3.73k|  }
_ZNK4absl12lts_2024011619str_format_internal14FormatSinkImpl5AvailEv:
  123|  3.73k|  size_t Avail() const {
  124|  3.73k|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  3.73k|  }
_ZN4absl12lts_2024011619str_format_internal17FormatRawSinkImplC2INS1_11FILERawSinkETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE_EEELPv0EEES6_:
   46|  3.73k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2024011619str_format_internal17FormatRawSinkImpl5FlushINS1_11FILERawSinkEEEvPvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
   57|  3.73k|  static void Flush(void* r, string_view s) {
   58|  3.73k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  3.73k|  }

_ZN4absl12lts_2024011619str_format_internal11FILERawSink5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   42|  3.73k|void FILERawSink::Write(string_view v) {
   43|  7.46k|  while (!v.empty() && !error_) {
  ------------------
  |  Branch (43:10): [True: 3.73k, False: 3.73k]
  |  Branch (43:24): [True: 3.73k, False: 0]
  ------------------
   44|       |    // Reset errno to zero in case the libc implementation doesn't set errno
   45|       |    // when a failure occurs.
   46|  3.73k|    ClearErrnoGuard guard;
   47|       |
   48|  3.73k|    if (size_t result = std::fwrite(v.data(), 1, v.size(), output_)) {
  ------------------
  |  Branch (48:16): [True: 3.73k, False: 0]
  ------------------
   49|       |      // Some progress was made.
   50|  3.73k|      count_ += result;
   51|  3.73k|      v.remove_prefix(result);
   52|  3.73k|    } else {
   53|      0|      if (errno == EINTR) {
  ------------------
  |  Branch (53:11): [True: 0, False: 0]
  ------------------
   54|      0|        continue;
   55|      0|      } else if (errno) {
  ------------------
  |  Branch (55:18): [True: 0, False: 0]
  ------------------
   56|      0|        error_ = errno;
   57|      0|      } else if (std::ferror(output_)) {
  ------------------
  |  Branch (57:18): [True: 0, False: 0]
  ------------------
   58|       |        // Non-POSIX compliant libc implementations may not set errno, so we
   59|       |        // have check the streams error indicator.
   60|      0|        error_ = EBADF;
   61|      0|      } else {
   62|       |        // We're likely on a non-POSIX system that encountered EINTR but had no
   63|       |        // way of reporting it.
   64|      0|        continue;
   65|      0|      }
   66|      0|    }
   67|  3.73k|  }
   68|  3.73k|}
output.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_115ClearErrnoGuardC2Ev:
   26|  3.73k|  ClearErrnoGuard() : old_value(errno) { errno = 0; }
output.cc:_ZN4absl12lts_2024011619str_format_internal12_GLOBAL__N_115ClearErrnoGuardD2Ev:
   27|  3.73k|  ~ClearErrnoGuard() {
   28|  3.73k|    if (!errno) errno = old_value;
  ------------------
  |  Branch (28:9): [True: 3.73k, False: 0]
  ------------------
   29|  3.73k|  }

_ZN4absl12lts_2024011619str_format_internal11FILERawSinkC2EP8_IO_FILE:
   57|  3.73k|  explicit FILERawSink(std::FILE* output) : output_(output) {}
_ZNK4absl12lts_2024011619str_format_internal11FILERawSink5countEv:
   61|  7.46k|  size_t count() const { return count_; }
_ZNK4absl12lts_2024011619str_format_internal11FILERawSink5errorEv:
   62|  3.73k|  int error() const { return error_; }
_ZN4absl12lts_2024011619str_format_internal15AbslFormatFlushEPNS1_11FILERawSinkENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
   78|  3.73k|inline void AbslFormatFlush(FILERawSink* sink, string_view v) {
   79|  3.73k|  sink->Write(v);
   80|  3.73k|}
_ZN4absl12lts_2024011619str_format_internal11InvokeFlushINS1_11FILERawSinkEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   89|  3.73k|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|  3.73k|  AbslFormatFlush(out, s);
   91|  3.73k|}

bind.cc:_ZN4absl12lts_2024011619str_format_internal17ParseFormatStringINS1_12_GLOBAL__N_117ConverterConsumerINS3_16DefaultConverterEEEEEbNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEET_:
   57|  3.73k|bool ParseFormatString(string_view src, Consumer consumer) {
   58|  3.73k|  int next_arg = 0;
   59|  3.73k|  const char* p = src.data();
   60|  3.73k|  const char* const end = p + src.size();
   61|  3.73k|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 3.73k, False: 0]
  ------------------
   62|  3.73k|    const char* percent =
   63|  3.73k|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|  3.73k|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 3.73k, False: 0]
  ------------------
   65|       |      // We found the last substring.
   66|  3.73k|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|  3.73k|    }
   68|       |    // We found a percent, so push the text run then process the percent.
   69|      0|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   70|      0|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|      0|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   74|       |
   75|      0|    auto tag = GetTagForChar(percent[1]);
   76|      0|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 0, False: 0]
  ------------------
   77|      0|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   78|       |        // This indicates an error in the format string.
   79|       |        // The only way to get `next_arg < 0` here is to have a positional
   80|       |        // argument first which sets next_arg to -1 and then a non-positional
   81|       |        // argument.
   82|      0|        return false;
   83|      0|      }
   84|      0|      p = percent + 2;
   85|       |
   86|       |      // Keep this case separate from the one below.
   87|       |      // ConvertOne is more efficient when the compiler can see that the `basic`
   88|       |      // flag is set.
   89|      0|      UnboundConversion conv;
   90|      0|      conv.conv = tag.as_conv();
   91|      0|      conv.arg_position = ++next_arg;
   92|      0|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   93|      0|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|      0|    } else if (percent[1] != '%') {
  ------------------
  |  Branch (96:16): [True: 0, False: 0]
  ------------------
   97|      0|      UnboundConversion conv;
   98|      0|      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
   99|      0|      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  100|      0|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  101|      0|              conv, string_view(percent + 1,
  102|      0|                                static_cast<size_t>(p - (percent + 1)))))) {
  103|      0|        return false;
  104|      0|      }
  105|      0|    } else {
  106|      0|      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  107|      0|      p = percent + 2;
  108|      0|      continue;
  109|      0|    }
  110|      0|  }
  111|      0|  return true;
  112|  3.73k|}

_ZN4absl12lts_2024011611StrContainsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   47|      2|                        absl::string_view needle) noexcept {
   48|      2|  return haystack.find(needle, 0) != haystack.npos;
   49|      2|}
_ZN4absl12lts_2024011610StartsWithENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   59|     10|                       absl::string_view prefix) noexcept {
   60|     10|  return prefix.empty() ||
  ------------------
  |  Branch (60:10): [True: 0, False: 10]
  ------------------
   61|     10|         (text.size() >= prefix.size() &&
  ------------------
  |  Branch (61:11): [True: 10, False: 0]
  ------------------
   62|     10|          memcmp(text.data(), prefix.data(), prefix.size()) == 0);
  ------------------
  |  Branch (62:11): [True: 8, False: 2]
  ------------------
   63|     10|}

_ZN4absl12lts_2024011610SimpleAtodENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPd:
   83|  24.5k|bool SimpleAtod(absl::string_view str, absl::Nonnull<double*> out) {
   84|  24.5k|  *out = 0.0;
   85|  24.5k|  str = StripAsciiWhitespace(str);
   86|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   87|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   88|  24.5k|  if (!str.empty() && str[0] == '+') {
  ------------------
  |  Branch (88:7): [True: 24.5k, False: 8]
  |  Branch (88:23): [True: 354, False: 24.2k]
  ------------------
   89|    354|    str.remove_prefix(1);
   90|    354|    if (!str.empty() && str[0] == '-') {
  ------------------
  |  Branch (90:9): [True: 353, False: 1]
  |  Branch (90:25): [True: 1, False: 352]
  ------------------
   91|      1|      return false;
   92|      1|    }
   93|    354|  }
   94|  24.5k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
   95|  24.5k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (95:7): [True: 149, False: 24.4k]
  ------------------
   96|    149|    return false;
   97|    149|  }
   98|  24.4k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (98:7): [True: 341, False: 24.1k]
  ------------------
   99|       |    // not all non-whitespace characters consumed
  100|    341|    return false;
  101|    341|  }
  102|       |  // from_chars() with DR 3081's current wording will return max() on
  103|       |  // overflow.  SimpleAtod returns infinity instead.
  104|  24.1k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (104:7): [True: 3.58k, False: 20.5k]
  ------------------
  105|  3.58k|    if (*out > 1.0) {
  ------------------
  |  Branch (105:9): [True: 2.15k, False: 1.42k]
  ------------------
  106|  2.15k|      *out = std::numeric_limits<double>::infinity();
  107|  2.15k|    } else if (*out < -1.0) {
  ------------------
  |  Branch (107:16): [True: 208, False: 1.22k]
  ------------------
  108|    208|      *out = -std::numeric_limits<double>::infinity();
  109|    208|    }
  110|  3.58k|  }
  111|  24.1k|  return true;
  112|  24.4k|}
_ZN4absl12lts_2024011616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1360|  11.9k|                        int base) {
 1361|  11.9k|  return safe_uint_internal<uint64_t>(text, value, base);
 1362|  11.9k|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
  923|  11.9k|    absl::Nonnull<bool*> negative_ptr /*output*/) {
  924|  11.9k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (924:7): [True: 0, False: 11.9k]
  ------------------
  925|      0|    return false;
  926|      0|  }
  927|       |
  928|  11.9k|  const char* start = text->data();
  929|  11.9k|  const char* end = start + text->size();
  930|  11.9k|  int base = *base_ptr;
  931|       |
  932|       |  // Consume whitespace.
  933|  11.9k|  while (start < end &&
  ------------------
  |  Branch (933:10): [True: 11.9k, False: 8]
  ------------------
  934|  11.9k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (934:10): [True: 0, False: 11.9k]
  ------------------
  935|      0|    ++start;
  936|      0|  }
  937|  12.1k|  while (start < end &&
  ------------------
  |  Branch (937:10): [True: 12.1k, False: 8]
  ------------------
  938|  12.1k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (938:10): [True: 200, False: 11.9k]
  ------------------
  939|    200|    --end;
  940|    200|  }
  941|  11.9k|  if (start >= end) {
  ------------------
  |  Branch (941:7): [True: 8, False: 11.9k]
  ------------------
  942|      8|    return false;
  943|      8|  }
  944|       |
  945|       |  // Consume sign.
  946|  11.9k|  *negative_ptr = (start[0] == '-');
  947|  11.9k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (947:7): [True: 2, False: 11.9k]
  |  Branch (947:24): [True: 251, False: 11.6k]
  ------------------
  948|    253|    ++start;
  949|    253|    if (start >= end) {
  ------------------
  |  Branch (949:9): [True: 7, False: 246]
  ------------------
  950|      7|      return false;
  951|      7|    }
  952|    253|  }
  953|       |
  954|       |  // Consume base-dependent prefix.
  955|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
  956|       |  //  base 16: "0x" -> base 16
  957|       |  // Also validate the base.
  958|  11.9k|  if (base == 0) {
  ------------------
  |  Branch (958:7): [True: 0, False: 11.9k]
  ------------------
  959|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (959:9): [True: 0, False: 0]
  |  Branch (959:29): [True: 0, False: 0]
  ------------------
  960|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (960:10): [True: 0, False: 0]
  |  Branch (960:29): [True: 0, False: 0]
  ------------------
  961|      0|      base = 16;
  962|      0|      start += 2;
  963|      0|      if (start >= end) {
  ------------------
  |  Branch (963:11): [True: 0, False: 0]
  ------------------
  964|       |        // "0x" with no digits after is invalid.
  965|      0|        return false;
  966|      0|      }
  967|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (967:16): [True: 0, False: 0]
  |  Branch (967:36): [True: 0, False: 0]
  ------------------
  968|      0|      base = 8;
  969|      0|      start += 1;
  970|      0|    } else {
  971|      0|      base = 10;
  972|      0|    }
  973|  11.9k|  } else if (base == 16) {
  ------------------
  |  Branch (973:14): [True: 0, False: 11.9k]
  ------------------
  974|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (974:9): [True: 0, False: 0]
  |  Branch (974:29): [True: 0, False: 0]
  ------------------
  975|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (975:10): [True: 0, False: 0]
  |  Branch (975:29): [True: 0, False: 0]
  ------------------
  976|      0|      start += 2;
  977|      0|      if (start >= end) {
  ------------------
  |  Branch (977:11): [True: 0, False: 0]
  ------------------
  978|       |        // "0x" with no digits after is invalid.
  979|      0|        return false;
  980|      0|      }
  981|      0|    }
  982|  11.9k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (982:14): [True: 11.9k, False: 0]
  |  Branch (982:27): [True: 11.9k, False: 0]
  ------------------
  983|       |    // okay
  984|  11.9k|  } else {
  985|      0|    return false;
  986|      0|  }
  987|  11.9k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
  988|  11.9k|  *base_ptr = base;
  989|  11.9k|  return true;
  990|  11.9k|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1305|  11.9k|                               absl::Nonnull<IntType*> value_p, int base) {
 1306|  11.9k|  *value_p = 0;
 1307|  11.9k|  bool negative;
 1308|  11.9k|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1308:7): [True: 15, False: 11.9k]
  |  Branch (1308:61): [True: 1, False: 11.9k]
  ------------------
 1309|     16|    return false;
 1310|     16|  }
 1311|  11.9k|  return safe_parse_positive_int(text, base, value_p);
 1312|  11.9k|}
numbers.cc:_ZN4absl12lts_2024011612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1208|  11.9k|                                    absl::Nonnull<IntType*> value_p) {
 1209|  11.9k|  IntType value = 0;
 1210|  11.9k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1211|  11.9k|  assert(vmax > 0);
 1212|  11.9k|  assert(base >= 0);
 1213|  11.9k|  const IntType base_inttype = static_cast<IntType>(base);
 1214|  11.9k|  assert(vmax >= base_inttype);
 1215|  11.9k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1216|  11.9k|  assert(base < 2 ||
 1217|  11.9k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1218|  11.9k|  const char* start = text.data();
 1219|  11.9k|  const char* end = start + text.size();
 1220|       |  // loop over digits
 1221|  26.6k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1221:10): [True: 14.8k, False: 11.8k]
  ------------------
 1222|  14.8k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1223|  14.8k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1224|  14.8k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1224:9): [True: 50, False: 14.7k]
  ------------------
 1225|     50|      *value_p = value;
 1226|     50|      return false;
 1227|     50|    }
 1228|  14.7k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1228:9): [True: 75, False: 14.6k]
  ------------------
 1229|     75|      *value_p = vmax;
 1230|     75|      return false;
 1231|     75|    }
 1232|  14.6k|    value *= base_inttype;
 1233|  14.6k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1233:9): [True: 1, False: 14.6k]
  ------------------
 1234|      1|      *value_p = vmax;
 1235|      1|      return false;
 1236|      1|    }
 1237|  14.6k|    value += digit;
 1238|  14.6k|  }
 1239|  11.8k|  *value_p = value;
 1240|  11.8k|  return true;
 1241|  11.9k|}

_ZN4absl12lts_2024011616numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  354|  11.9k|                                           int base) {
  355|  11.9k|  static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
  356|  11.9k|                "SimpleAtoi works only with 32-bit or 64-bit integers.");
  357|  11.9k|  static_assert(!std::is_floating_point<int_type>::value,
  358|  11.9k|                "Use SimpleAtof or SimpleAtod instead.");
  359|  11.9k|  bool parsed;
  360|       |  // TODO(jorg): This signed-ness check is used because it works correctly
  361|       |  // with enums, and it also serves to check that int_type is not a pointer.
  362|       |  // If one day something like std::is_signed<enum E> works, switch to it.
  363|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  364|  11.9k|  constexpr bool kIsSigned = static_cast<int_type>(1) - 2 < 0;
  365|  11.9k|  constexpr bool kUse64Bit = sizeof(*out) == 64 / 8;
  366|  11.9k|  if (kIsSigned) {
  ------------------
  |  Branch (366:7): [Folded, False: 11.9k]
  ------------------
  367|      0|    if (kUse64Bit) {
  ------------------
  |  Branch (367:9): [True: 0, Folded]
  ------------------
  368|      0|      int64_t val;
  369|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  370|      0|      *out = static_cast<int_type>(val);
  371|      0|    } else {
  372|      0|      int32_t val;
  373|      0|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  374|      0|      *out = static_cast<int_type>(val);
  375|      0|    }
  376|  11.9k|  } else {
  377|  11.9k|    if (kUse64Bit) {
  ------------------
  |  Branch (377:9): [True: 11.9k, Folded]
  ------------------
  378|  11.9k|      uint64_t val;
  379|  11.9k|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  380|  11.9k|      *out = static_cast<int_type>(val);
  381|  11.9k|    } else {
  382|      0|      uint32_t val;
  383|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  384|      0|      *out = static_cast<int_type>(val);
  385|      0|    }
  386|  11.9k|  }
  387|  11.9k|  return parsed;
  388|  11.9k|}
_ZN4absl12lts_2024011610SimpleAtoiImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  423|  11.9k|                                     absl::Nonnull<int_type*> out) {
  424|  11.9k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  425|  11.9k|}

_ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_:
   58|      2|std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
   59|      2|  std::string result;
   60|      2|  absl::strings_internal::STLStringResizeUninitialized(&result,
   61|      2|                                                       a.size() + b.size());
   62|      2|  char* const begin = &result[0];
   63|      2|  char* out = begin;
   64|      2|  out = Append(out, a);
   65|      2|  out = Append(out, b);
   66|       |  assert(out == begin + result.size());
   67|      2|  return result;
   68|      2|}
_ZN4absl12lts_202401166StrCatERKNS0_8AlphaNumES3_S3_:
   70|      8|std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) {
   71|      8|  std::string result;
   72|      8|  strings_internal::STLStringResizeUninitialized(
   73|      8|      &result, a.size() + b.size() + c.size());
   74|      8|  char* const begin = &result[0];
   75|      8|  char* out = begin;
   76|      8|  out = Append(out, a);
   77|      8|  out = Append(out, b);
   78|      8|  out = Append(out, c);
   79|       |  assert(out == begin + result.size());
   80|      8|  return result;
   81|      8|}
str_cat.cc:_ZN4absl12lts_2024011612_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE:
   46|     28|absl::Nonnull<char*> Append(absl::Nonnull<char*> out, const AlphaNum& x) {
   47|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   48|       |  // call would force an extra fetch of x.size().
   49|     28|  char* after = out + x.size();
   50|     28|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 26, False: 2]
  ------------------
   51|     26|    memcpy(out, x.data(), x.size());
   52|     26|  }
   53|     28|  return after;
   54|     28|}

_ZN4absl12lts_202401168AlphaNumC2EPKc:
  353|      8|      : piece_(NullSafeStringView(c_str)) {}
_ZN4absl12lts_202401168AlphaNumC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  356|      6|      : piece_(pc) {}
_ZNK4absl12lts_202401168AlphaNum4sizeEv:
  377|    110|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202401168AlphaNum4dataEv:
  378|     26|  absl::Nullable<const char*> data() const { return piece_.data(); }
_ZN4absl12lts_202401168AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  369|     14|      : piece_(str) {}

_ZN4absl12lts_2024011617UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  111|  3.73k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202401167FPrintFIJEEEiP8_IO_FILERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKS6_:
  441|  3.73k|            const Args&... args) {
  442|  3.73k|  return str_format_internal::FprintF(
  443|  3.73k|      output, str_format_internal::UntypedFormatSpecImpl::Extract(format),
  444|  3.73k|      {str_format_internal::FormatArgImpl(args)...});
  445|  3.73k|}

_ZN4absl12lts_2024011618NullSafeStringViewEPKc:
  762|      8|constexpr string_view NullSafeStringView(absl::Nullable<const char*> p) {
  763|      8|  return p ? string_view(p) : string_view();
  ------------------
  |  Branch (763:10): [True: 8, False: 0]
  ------------------
  764|      8|}

_ZN4absl12lts_2024011613ConsumePrefixEPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   48|      8|                          absl::string_view expected) {
   49|      8|  if (!absl::StartsWith(*str, expected)) return false;
  ------------------
  |  Branch (49:7): [True: 0, False: 8]
  ------------------
   50|      8|  str->remove_prefix(expected.size());
   51|      8|  return true;
   52|      8|}

_ZN4absl12lts_2024011624synchronization_internal14InvalidGraphIdEv:
   58|  3.87k|inline GraphId InvalidGraphId() {
   59|  3.87k|  return GraphId{0};
   60|  3.87k|}

_ZN4absl12lts_202401165Mutex4LockEv:
 1524|  3.87k|void Mutex::Lock() {
 1525|  3.87k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1526|  3.87k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1527|  3.87k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1528|       |  // try fast acquire, then spin loop
 1529|  3.87k|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  178|  7.74k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 3.87k]
  |  |  |  Branch (178:49): [Folded, False: 3.87k]
  |  |  |  Branch (178:58): [True: 0, False: 3.87k]
  |  |  ------------------
  ------------------
 1530|  3.87k|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  178|  3.87k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 3.87k]
  |  |  |  Branch (178:49): [Folded, False: 3.87k]
  |  |  |  Branch (178:58): [True: 0, False: 3.87k]
  |  |  ------------------
  ------------------
 1531|  3.87k|          v, kMuWriter | v, std::memory_order_acquire,
 1532|  3.87k|          std::memory_order_relaxed))) {
 1533|       |    // try spin acquire, then slow loop
 1534|      0|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  178|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (178:31): [True: 0, False: 0]
  |  |  |  Branch (178:49): [Folded, False: 0]
  |  |  |  Branch (178:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1535|      0|      this->LockSlow(kExclusive, nullptr, 0);
 1536|      0|    }
 1537|      0|  }
 1538|  3.87k|  DebugOnlyLockEnter(this, id);
 1539|  3.87k|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1540|  3.87k|}
_ZN4absl12lts_202401165Mutex6UnlockEv:
 1702|  3.87k|void Mutex::Unlock() {
 1703|  3.87k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1704|  3.87k|  DebugOnlyLockLeave(this);
 1705|  3.87k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1706|       |
 1707|  3.87k|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1707:7): [Folded, False: 3.87k]
  |  Branch (1707:21): [True: 0, False: 0]
  ------------------
 1708|      0|    ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1709|      0|                 static_cast<unsigned>(v));
 1710|      0|  }
 1711|       |
 1712|       |  // should_try_cas is whether we'll try a compare-and-swap immediately.
 1713|       |  // NOTE: optimized out when kDebugMode is false.
 1714|  3.87k|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1714:26): [True: 3.87k, False: 0]
  ------------------
 1715|  3.87k|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1715:26): [True: 3.87k, False: 0]
  ------------------
 1716|       |  // But, we can use an alternate computation of it, that compilers
 1717|       |  // currently don't find on their own.  When that changes, this function
 1718|       |  // can be simplified.
 1719|  3.87k|  intptr_t x = (v ^ (kMuWriter | kMuWait)) & (kMuWriter | kMuEvent);
 1720|  3.87k|  intptr_t y = (v ^ (kMuWriter | kMuWait)) & (kMuWait | kMuDesig);
 1721|       |  // Claim: "x == 0 && y > 0" is equal to should_try_cas.
 1722|       |  // Also, because kMuWriter and kMuEvent exceed kMuDesig and kMuWait,
 1723|       |  // all possible non-zero values for x exceed all possible values for y.
 1724|       |  // Therefore, (x == 0 && y > 0) == (x < y).
 1725|  3.87k|  if (kDebugMode && should_try_cas != (x < y)) {
  ------------------
  |  Branch (1725:7): [Folded, False: 3.87k]
  |  Branch (1725:21): [True: 0, False: 0]
  ------------------
 1726|       |    // We would usually use PRIdPTR here, but is not correctly implemented
 1727|       |    // within the android toolchain.
 1728|      0|    ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1729|      0|                 static_cast<long long>(v), static_cast<long long>(x),
 1730|      0|                 static_cast<long long>(y));
 1731|      0|  }
 1732|  3.87k|  if (x < y && mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1732:7): [True: 3.87k, False: 0]
  |  Branch (1732:16): [True: 3.87k, False: 0]
  ------------------
 1733|  3.87k|                                           std::memory_order_release,
 1734|  3.87k|                                           std::memory_order_relaxed)) {
 1735|       |    // fast writer release (writer with no waiters or with designated waker)
 1736|  3.87k|  } else {
 1737|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1738|      0|  }
 1739|  3.87k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1740|  3.87k|}
mutex.cc:_ZN4absl12lts_20240116L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1466|  3.87k|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1467|  3.87k|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1467:7): [Folded, False: 3.87k]
  |  Branch (1467:21): [True: 0, False: 0]
  ------------------
 1468|      0|                        OnDeadlockCycle::kIgnore) {
 1469|      0|    return DeadlockCheck(mu);
 1470|  3.87k|  } else {
 1471|  3.87k|    return InvalidGraphId();
 1472|  3.87k|  }
 1473|  3.87k|}
mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1298|  3.87k|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1299|  3.87k|  if (kDebugMode) {
  ------------------
  |  Branch (1299:7): [Folded, False: 3.87k]
  ------------------
 1300|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1300:9): [True: 0, False: 0]
  ------------------
 1301|      0|        OnDeadlockCycle::kIgnore) {
 1302|      0|      LockEnter(mu, id, Synch_GetAllLocks());
 1303|      0|    }
 1304|      0|  }
 1305|  3.87k|}
mutex.cc:_ZN4absl12lts_20240116L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1308|  3.87k|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1309|  3.87k|  if (kDebugMode) {
  ------------------
  |  Branch (1309:7): [Folded, False: 3.87k]
  ------------------
 1310|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1310:9): [True: 0, False: 0]
  ------------------
 1311|      0|        OnDeadlockCycle::kIgnore) {
 1312|      0|      LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
 1313|      0|    }
 1314|      0|  }
 1315|  3.87k|}

_ZN4absl12lts_202401169MutexLockC2EPNS0_5MutexE:
  583|  3.83k|  explicit MutexLock(Mutex* mu) ABSL_EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
  584|  3.83k|    this->mu_->Lock();
  585|  3.83k|  }
_ZN4absl12lts_202401169MutexLockD2Ev:
  601|  3.83k|  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_->Unlock(); }
_ZN4absl12lts_202401165MutexC2Ev:
 1061|     34|inline Mutex::Mutex() : mu_(0) {
 1062|     34|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 1063|     34|}

_ZN4absl12lts_202401163NowEv:
   39|  2.36k|Time Now() {
   40|       |  // TODO(bww): Get a timespec instead so we don't have to divide.
   41|  2.36k|  int64_t n = absl::GetCurrentTimeNanos();
   42|  2.36k|  if (n >= 0) {
  ------------------
  |  Branch (42:7): [True: 2.36k, False: 0]
  ------------------
   43|  2.36k|    return time_internal::FromUnixDuration(
   44|  2.36k|        time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
   45|  2.36k|  }
   46|      0|  return time_internal::FromUnixDuration(absl::Nanoseconds(n));
   47|  2.36k|}
_ZN4absl12lts_2024011619GetCurrentTimeNanosEv:
   77|  2.36k|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
  ------------------
  |  |   71|  2.36k|  ::absl::time_internal::GetCurrentTimeNanosFromSystem()
  ------------------

_ZN4absl12lts_202401168DurationmIES1_:
  419|  1.18k|Duration& Duration::operator-=(Duration rhs) {
  420|  1.18k|  if (time_internal::IsInfiniteDuration(*this)) return *this;
  ------------------
  |  Branch (420:7): [True: 0, False: 1.18k]
  ------------------
  421|  1.18k|  if (time_internal::IsInfiniteDuration(rhs)) {
  ------------------
  |  Branch (421:7): [True: 0, False: 1.18k]
  ------------------
  422|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (422:20): [True: 0, False: 0]
  ------------------
  423|      0|                                          : InfiniteDuration();
  424|      0|  }
  425|  1.18k|  const int64_t orig_rep_hi = rep_hi_.Get();
  426|  1.18k|  rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) -
  427|  1.18k|                           EncodeTwosComp(rhs.rep_hi_.Get()));
  428|  1.18k|  if (rep_lo_ < rhs.rep_lo_) {
  ------------------
  |  Branch (428:7): [True: 0, False: 1.18k]
  ------------------
  429|      0|    rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) - 1);
  430|      0|    rep_lo_ += kTicksPerSecond;
  431|      0|  }
  432|  1.18k|  rep_lo_ -= rhs.rep_lo_;
  433|  1.18k|  if (rhs.rep_hi_.Get() < 0 ? rep_hi_.Get() < orig_rep_hi
  ------------------
  |  Branch (433:7): [True: 0, False: 1.18k]
  |  Branch (433:7): [True: 0, False: 1.18k]
  ------------------
  434|  1.18k|                            : rep_hi_.Get() > orig_rep_hi) {
  435|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (435:20): [True: 0, False: 0]
  ------------------
  436|      0|                                          : InfiniteDuration();
  437|      0|  }
  438|  1.18k|  return *this;
  439|  1.18k|}
duration.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114DecodeTwosCompEm:
  187|  1.18k|inline int64_t DecodeTwosComp(uint64_t v) { return absl::bit_cast<int64_t>(v); }
duration.cc:_ZN4absl12lts_2024011612_GLOBAL__N_114EncodeTwosCompEl:
  184|  2.36k|inline uint64_t EncodeTwosComp(int64_t v) {
  185|  2.36k|  return absl::bit_cast<uint64_t>(v);
  186|  2.36k|}

clock.cc:_ZN4absl12lts_2024011613time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|  2.36k|static int64_t GetCurrentTimeNanosFromSystem() {
   14|  2.36k|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|  2.36k|  struct timespec ts;
   16|  2.36k|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|  2.36k|  do {                                                                 \
  |  |   61|  2.36k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  178|  2.36k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:31): [True: 0, False: 2.36k]
  |  |  |  |  |  Branch (178:49): [Folded, False: 2.36k]
  |  |  |  |  |  Branch (178:58): [True: 0, False: 2.36k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  225|      0|  do {                                           \
  |  |  |  |  |  |  |  |  226|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  227|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  228|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  203|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  229|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (229:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  2.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2.36k]
  |  |  ------------------
  ------------------
   17|  2.36k|                 "Failed to read real-time clock.");
   18|  2.36k|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|  2.36k|          int64_t{ts.tv_nsec});
   20|  2.36k|}

_ZN4absl12lts_202401168DurationC2Ev:
  169|  1.18k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202401168DurationC2Elj:
  231|  7.28k|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202401168Duration5HiRepC2El:
  251|  8.47k|          lo_(0),
  252|  8.47k|          hi_(0)
  253|       |#endif
  254|  8.47k|    {
  255|  8.47k|      *this = value;
  256|  8.47k|    }
_ZNK4absl12lts_202401168Duration5HiRep3GetEv:
  258|  15.7k|    constexpr int64_t Get() const {
  259|  15.7k|      const uint64_t unsigned_value =
  260|  15.7k|          (static_cast<uint64_t>(hi_) << 32) | static_cast<uint64_t>(lo_);
  261|       |      // `static_cast<int64_t>(unsigned_value)` is implementation-defined
  262|       |      // before c++20. On all supported platforms the behaviour is that mandated
  263|       |      // by c++20, i.e. "If the destination type is signed, [...] the result is
  264|       |      // the unique value of the destination type equal to the source value
  265|       |      // modulo 2^n, where n is the number of bits used to represent the
  266|       |      // destination type."
  267|  15.7k|      static_assert(
  268|  15.7k|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  269|  15.7k|           int64_t{-1}) &&
  270|  15.7k|              (static_cast<int64_t>(static_cast<uint64_t>(
  271|  15.7k|                                        (std::numeric_limits<int64_t>::max)()) +
  272|  15.7k|                                    1) ==
  273|  15.7k|               (std::numeric_limits<int64_t>::min)()),
  274|  15.7k|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  275|  15.7k|      return static_cast<int64_t>(unsigned_value);
  276|  15.7k|    }
_ZN4absl12lts_202401168Duration5HiRepaSEl:
  278|  9.66k|    constexpr HiRep& operator=(const int64_t value) {
  279|       |      // "If the destination type is unsigned, the resulting value is the
  280|       |      // smallest unsigned value equal to the source value modulo 2^n
  281|       |      // where `n` is the number of bits used to represent the destination
  282|       |      // type".
  283|  9.66k|      const auto unsigned_value = static_cast<uint64_t>(value);
  284|  9.66k|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  285|  9.66k|      lo_ = static_cast<uint32_t>(unsigned_value);
  286|  9.66k|      return *this;
  287|  9.66k|    }
_ZN4absl12lts_202401164TimeC2ENS0_8DurationE:
  850|  7.28k|  constexpr explicit Time(Duration rep) : rep_(rep) {}
_ZN4absl12lts_20240116leENS0_8DurationES1_:
  320|      2|                                                        Duration rhs) {
  321|      2|  return !(rhs < lhs);
  322|      2|}
_ZN4absl12lts_20240116miENS0_8DurationES1_:
  337|  1.18k|                                                        Duration rhs) {
  338|  1.18k|  return lhs -= rhs;
  339|  1.18k|}
_ZN4absl12lts_2024011612ZeroDurationEv:
  416|  1.18k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  417|  1.18k|  return Duration();
  418|  1.18k|}
_ZN4absl12lts_20240116eqENS0_4TimeES1_:
  867|  4.91k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator==(Time lhs, Time rhs) {
  868|  4.91k|  return lhs.rep_ == rhs.rep_;
  869|  4.91k|}
_ZN4absl12lts_20240116neENS0_4TimeES1_:
  870|  4.91k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool operator!=(Time lhs, Time rhs) {
  871|  4.91k|  return !(lhs == rhs);
  872|  4.91k|}
_ZN4absl12lts_20240116miENS0_4TimeES1_:
  884|  1.18k|ABSL_ATTRIBUTE_CONST_FUNCTION inline Duration operator-(Time lhs, Time rhs) {
  885|  1.18k|  return lhs.rep_ - rhs.rep_;
  886|  1.18k|}
_ZN4absl12lts_2024011614InfiniteFutureEv:
  907|  4.91k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time InfiniteFuture() {
  908|  4.91k|  return Time(time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
  909|  4.91k|                                          ~uint32_t{0}));
  910|  4.91k|}
_ZN4absl12lts_2024011613time_internal12MakeDurationElj:
 1561|  7.28k|                                                              uint32_t lo = 0) {
 1562|  7.28k|  return Duration(hi, lo);
 1563|  7.28k|}
_ZN4absl12lts_2024011613time_internal12MakeDurationEll:
 1566|  2.36k|                                                              int64_t lo) {
 1567|  2.36k|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1568|  2.36k|}
_ZN4absl12lts_2024011613time_internal8GetRepHiENS0_8DurationE:
 1593|  9.83k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1594|  9.83k|  return d.rep_hi_.Get();
 1595|  9.83k|}
_ZN4absl12lts_2024011613time_internal8GetRepLoENS0_8DurationE:
 1596|  12.1k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1597|  12.1k|  return d.rep_lo_;
 1598|  12.1k|}
_ZN4absl12lts_2024011613time_internal18IsInfiniteDurationENS0_8DurationE:
 1601|  2.36k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1602|  2.36k|  return GetRepLo(d) == ~uint32_t{0};
 1603|  2.36k|}
_ZN4absl12lts_2024011613time_internal16FromUnixDurationENS0_8DurationE:
 1626|  2.36k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1627|  2.36k|  return Time(d);
 1628|  2.36k|}
_ZN4absl12lts_20240116ltENS0_8DurationES1_:
 1721|      2|                                                       Duration rhs) {
 1722|      2|  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
  ------------------
  |  Branch (1722:10): [True: 2, False: 0]
  ------------------
 1723|      2|             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
 1724|      2|         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
  ------------------
  |  Branch (1724:12): [True: 0, False: 0]
  ------------------
 1725|      0|             ? time_internal::GetRepLo(lhs) + 1 <
 1726|      0|                   time_internal::GetRepLo(rhs) + 1
 1727|      0|             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
 1728|      2|}
_ZN4absl12lts_20240116eqENS0_8DurationES1_:
 1731|  4.91k|                                                        Duration rhs) {
 1732|  4.91k|  return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
  ------------------
  |  Branch (1732:10): [True: 4.91k, False: 0]
  ------------------
 1733|  4.91k|         time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
  ------------------
  |  Branch (1733:10): [True: 4.91k, False: 0]
  ------------------
 1734|  4.91k|}
_ZN4absl12lts_2024011616InfiniteDurationEv:
 1762|      4|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration InfiniteDuration() {
 1763|      4|  return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
 1764|      4|                                     ~uint32_t{0});
 1765|      4|}
_ZN4absl12lts_202401164TimeC2Ev:
  780|      4|  constexpr Time() = default;

_ZN4absl12lts_2024011613span_internal7GetDataIKNSt3__16vectorIN8fuzztest8internal8IRObjectENS3_9allocatorIS7_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|  1.31k|    -> decltype(GetDataImpl(c, 0)) {
   51|  1.31k|  return GetDataImpl(c, 0);
   52|  1.31k|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNSt3__16vectorIN8fuzztest8internal8IRObjectENS3_9allocatorIS7_EEEEEEDTcldtfp_4dataEERT_c:
   38|  1.31k|    -> decltype(c.data()) {
   39|  1.31k|  return c.data();
   40|  1.31k|}
_ZN4absl12lts_2024011613span_internal7GetDataIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|      2|    -> decltype(GetDataImpl(c, 0)) {
   51|      2|  return GetDataImpl(c, 0);
   52|      2|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNSt3__16vectorIjNS3_9allocatorIjEEEEEEDTcldtfp_4dataEERT_c:
   38|      2|    -> decltype(c.data()) {
   39|      2|  return c.data();
   40|      2|}
_ZN4absl12lts_2024011613span_internal7GetDataIKNS0_4SpanIjEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|     16|    -> decltype(GetDataImpl(c, 0)) {
   51|     16|  return GetDataImpl(c, 0);
   52|     16|}
_ZN4absl12lts_2024011613span_internal11GetDataImplIKNS0_4SpanIjEEEEDTcldtfp_4dataEERT_c:
   38|     16|    -> decltype(c.data()) {
   39|     16|  return c.data();
   40|     16|}

_ZN4absl12lts_202401164SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  193|  3.73k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKNS0_19str_format_internal13FormatArgImplEEC2Ev:
  191|  3.73k|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2INSt3__16vectorIS4_NS8_9allocatorIS4_EEEEvSC_iEERKT_:
  217|  1.31k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2EPS5_m:
  193|  1.31k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEEC2Ev:
  191|      3|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE4sizeEv:
  286|  1.31k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE5beginEv:
  336|  1.20k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202401164SpanIKN8fuzztest8internal8IRObjectEE4dataEv:
  281|  1.20k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIhE4dataEv:
  281|      2|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIhE4sizeEv:
  286|      2|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202401164SpanIjE4dataEv:
  281|     20|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIjE4sizeEv:
  286|     20|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202401168MakeSpanITpTnRiJEhEENS0_4SpanIT0_EEPS4_m:
  685|      2|constexpr Span<T> MakeSpan(absl::Nullable<T*> ptr, size_t size) noexcept {
  686|      2|  return Span<T>(ptr, size);
  687|      2|}
_ZN4absl12lts_202401164SpanIhEC2EPhm:
  193|      2|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202401164SpanIKjEC2INSt3__16vectorIjNS5_9allocatorIjEEEEvS9_iEERKT_:
  217|      2|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202401164SpanIKjEC2EPS2_m:
  193|     18|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202401164SpanIKjE4dataEv:
  281|     34|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202401164SpanIKjE4sizeEv:
  286|     18|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202401168MakeSpanITpTnRiJEjLm512EEENS0_4SpanIT0_EERAT1__S4_:
  702|      2|constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
  703|      2|  return Span<T>(array, N);
  704|      2|}
_ZN4absl12lts_202401164SpanIjEC2EPjm:
  193|     18|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202401164SpanIKjE5beginEv:
  336|     16|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202401164SpanIKjE3endEv:
  349|     16|  constexpr iterator end() const noexcept { return data() + size(); }
_ZN4absl12lts_202401168MakeSpanITpTnRiJEjEENS0_4SpanIT0_EEPS4_m:
  685|     16|constexpr Span<T> MakeSpan(absl::Nullable<T*> ptr, size_t size) noexcept {
  686|     16|  return Span<T>(ptr, size);
  687|     16|}
_ZN4absl12lts_202401164SpanIKjEC2INS1_IjEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  232|     16|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202401164SpanIjE5emptyEv:
  296|      2|  constexpr bool empty() const noexcept { return size() == 0; }

_ZN4absl12lts_202401167forwardINS0_18container_internal12CommonFieldsEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}
_ZN4absl12lts_202401167forwardINS0_18container_internal10StringHashEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}
_ZN4absl12lts_202401167forwardINS0_18container_internal8StringEqEEEOT_RNSt3__116remove_referenceIS4_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}
_ZN4absl12lts_202401167forwardINSt3__19allocatorINS2_4pairIKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_15CommandLineFlagEEEEEEEOT_RNS2_16remove_referenceISE_E4typeE:
  149|      6|    absl::remove_reference_t<T>& t) noexcept {  // NOLINT(runtime/references)
  150|      6|  return static_cast<T&&>(t);
  151|      6|}

_ZN8fuzztest15internal_no_adl7TupleOfITpTnRiJEJNS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_13ArbitraryImplIcvEEEEEEEDaDpT0_:
  564|      2|auto TupleOf(Inner... inner) {
  565|      2|  return internal::AggregateOfImpl<std::tuple<internal::value_type_t<Inner>...>,
  566|      2|                                   internal::RequireCustomCorpusType::kNo,
  567|      2|                                   Inner...>(std::in_place,
  568|      2|                                             std::move(inner)...);
  569|      2|}
_ZN8fuzztest15internal_no_adl6StringEv:
  500|      2|inline auto String() { return Arbitrary<std::string>(); }
_ZN8fuzztest15internal_no_adl9ArbitraryINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDav:
  274|      2|auto Arbitrary() {
  275|      2|  return internal::ArbitraryImpl<T>{};
  276|      2|}

main:
   21|      2|int main(int argc, char** argv) {
   22|      2|  testing::InitGoogleTest(&argc, argv);
   23|       |  // We call fuzztest::ParseAbslFlagsrather than absl::ParseCommandLine
   24|       |  // since the latter would complain about any unknown flags that need
   25|       |  // to be passed to legacy fuzzing engines (e.g. libfuzzer).
   26|      2|  fuzztest::ParseAbslFlags(argc, argv);
   27|      2|  fuzztest::InitFuzzTest(&argc, &argv);
   28|      2|  return RUN_ALL_TESTS();
   29|      2|}

_ZN8fuzztest19ListRegisteredTestsEv:
  124|      4|std::vector<std::string> ListRegisteredTests() {
  125|      4|  std::vector<std::string> result;
  126|      4|  internal::ForEachTest(
  127|      4|      [&](const auto& test) { result.push_back(test.full_name()); });
  128|      4|  return result;
  129|      4|}
_ZN8fuzztest25GetMatchingFuzzTestOrExitENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  131|      2|std::string GetMatchingFuzzTestOrExit(std::string_view name) {
  132|      2|  const std::string partial_name(name);
  133|      2|  const std::vector<std::string> full_names = ListRegisteredTests();
  134|      2|  std::vector<const std::string*> matches;
  135|      2|  for (const std::string& full_name : full_names) {
  ------------------
  |  Branch (135:37): [True: 2, False: 0]
  ------------------
  136|      2|    if (absl::StrContains(full_name, partial_name)) {
  ------------------
  |  Branch (136:9): [True: 2, False: 0]
  ------------------
  137|      2|      if (full_name == partial_name) {
  ------------------
  |  Branch (137:11): [True: 2, False: 0]
  ------------------
  138|       |        // In case of an exact match, we end the search and use it. This is to
  139|       |        // handle the case when we want to select `MySuite.MyTest`, but the
  140|       |        // binary has both `MySuite.MyTest` and `MySuite.MyTestX`.
  141|      2|        return full_name;
  142|      2|      } else {
  143|      0|        matches.push_back(&full_name);
  144|      0|      }
  145|      2|    }
  146|      2|  }
  147|       |
  148|      0|  if (matches.empty()) {
  ------------------
  |  Branch (148:7): [True: 0, False: 0]
  ------------------
  149|      0|    absl::FPrintF(stderr, "\n\nNo FUZZ_TEST matches the name: %s\n\n",
  150|      0|                  partial_name);
  151|      0|    absl::FPrintF(stderr, "Valid tests:\n");
  152|      0|    for (const std::string& full_name : full_names) {
  ------------------
  |  Branch (152:39): [True: 0, False: 0]
  ------------------
  153|      0|      absl::FPrintF(stderr, " %s\n", full_name);
  154|      0|    }
  155|      0|    exit(1);
  156|      0|  } else if (matches.size() > 1) {
  ------------------
  |  Branch (156:14): [True: 0, False: 0]
  ------------------
  157|      0|    absl::FPrintF(stderr, "\n\nMultiple FUZZ_TESTs match the name: %s\n\n",
  158|      0|                  partial_name);
  159|      0|    absl::FPrintF(stderr, "Please select one. Matching tests:\n");
  160|      0|    for (const std::string* full_name : matches) {
  ------------------
  |  Branch (160:39): [True: 0, False: 0]
  ------------------
  161|      0|      absl::FPrintF(stderr, " %s\n", *full_name);
  162|      0|    }
  163|      0|    exit(1);
  164|      0|  }
  165|      0|  return *matches[0];
  166|      0|}
_ZN8fuzztest12InitFuzzTestEPiPPPcNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  241|      2|void InitFuzzTest(int* argc, char*** argv, std::string_view binary_id) {
  242|      2|  const char* centipede_binary = std::getenv("FUZZTEST_CENTIPEDE_BINARY");
  243|      2|  const bool is_runner_mode = std::getenv("CENTIPEDE_RUNNER_FLAGS");
  244|      2|  if (centipede_binary != nullptr && !is_runner_mode) {
  ------------------
  |  Branch (244:7): [True: 0, False: 2]
  |  Branch (244:38): [True: 0, False: 0]
  ------------------
  245|      0|    ExecvToCentipede(centipede_binary, *argc, *argv);
  246|      0|  }
  247|       |
  248|      2|  const bool is_listing = absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  249|      2|  if (is_listing) {
  ------------------
  |  Branch (249:7): [True: 0, False: 2]
  ------------------
  250|      0|    for (const auto& name : ListRegisteredTests()) {
  ------------------
  |  Branch (250:27): [True: 0, False: 0]
  ------------------
  251|      0|      std::cout << "[*] Fuzz test: " << name << '\n';
  252|      0|    }
  253|      0|    std::exit(0);
  254|      0|  }
  255|       |
  256|      2|  const auto test_to_fuzz = absl::GetFlag(FUZZTEST_FLAG(fuzz));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  257|      2|  const bool is_test_to_fuzz_specified = test_to_fuzz != kUnspecified;
  258|      2|  if (is_test_to_fuzz_specified) {
  ------------------
  |  Branch (258:7): [True: 2, False: 0]
  ------------------
  259|      2|    const std::string matching_fuzz_test =
  260|      2|        GetMatchingFuzzTestOrExit(test_to_fuzz);
  261|       |    // Delegate the test to GoogleTest.
  262|      2|    GTEST_FLAG_SET(filter, matching_fuzz_test);
  263|      2|  }
  264|       |
  265|      2|  std::string derived_binary_id =
  266|      2|      binary_id.empty() ? std::string(internal::Basename(*argv[0]))
  ------------------
  |  Branch (266:7): [True: 2, False: 0]
  ------------------
  267|      2|                        : std::string(binary_id);
  268|      2|  std::optional<std::string> reproduction_command_template;
  269|      2|  internal::Configuration configuration =
  270|      2|      CreateConfigurationsFromFlags(derived_binary_id);
  271|      2|  configuration.reproduction_command_template = reproduction_command_template;
  272|      2|  internal::RegisterFuzzTestsAsGoogleTests(argc, argv, configuration);
  273|       |
  274|      2|  const bool has_time_limit_per_test =
  275|      2|      configuration.time_limit_per_test < absl::InfiniteDuration();
  276|      2|  const RunMode run_mode = is_test_to_fuzz_specified || has_time_limit_per_test
  ------------------
  |  Branch (276:28): [True: 2, False: 0]
  |  Branch (276:57): [True: 0, False: 0]
  ------------------
  277|      2|                               ? RunMode::kFuzz
  278|      2|                               : RunMode::kUnitTest;
  279|       |
  280|      2|  if (run_mode == RunMode::kFuzz && !is_test_to_fuzz_specified &&
  ------------------
  |  Branch (280:7): [True: 2, False: 0]
  |  Branch (280:37): [True: 0, False: 2]
  ------------------
  281|      2|      GTEST_FLAG_GET(filter) == "*") {
  ------------------
  |  Branch (281:7): [True: 0, False: 0]
  ------------------
  282|       |    // Run only the fuzz tests, and not the unit tests when the user doesn't
  283|       |    // set the test filter.
  284|       |    // TODO: b/340232436 -- This is needed because we currently rely on a fuzz
  285|       |    // test being the first test to run so that Centipede can get the serialized
  286|       |    // configuration from the binary. For simplicity, we don't restrict the
  287|       |    // filter to fuzz tests when the user explicitly sets the filter. Instead of
  288|       |    // improving the logic here, once we fix b/340232436 we will remove this
  289|       |    // altogether and allow a mix of fuzz tests and unit tests in all cases.
  290|      0|    GTEST_FLAG_SET(filter, absl::StrJoin(configuration.fuzz_tests, ":"));
  291|      0|  }
  292|       |
  293|       |  // TODO(b/307513669): Use the Configuration class instead of Runtime.
  294|      2|  internal::Runtime::instance().SetRunMode(run_mode);
  295|      2|}
_ZN8fuzztest14ParseAbslFlagsEiPPc:
  297|      2|void ParseAbslFlags(int argc, char** argv) {
  298|      2|  std::vector<char*> positional_args;
  299|      2|  std::vector<absl::UnrecognizedFlag> unrecognized_flags;
  300|      2|  absl::ParseAbseilFlagsOnly(argc, argv, positional_args, unrecognized_flags);
  301|      2|}
init_fuzztest.cc:_ZNK3$_0clEv:
   47|      2|    .OnUpdate([]() {
   48|      2|      fuzztest::internal::SetFuzzTestListingModeValidatorForGoogleTest(
   49|      2|          absl::GetFlag(FUZZTEST_FLAG(list_fuzz_tests)));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
   50|      2|    });
init_fuzztest.cc:_ZN8fuzztest12_GLOBAL__N_129CreateConfigurationsFromFlagsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  171|      2|    absl::string_view binary_identifier) {
  172|      2|  bool reproduce_findings_as_separate_tests =
  173|      2|      absl::GetFlag(FUZZTEST_FLAG(reproduce_findings_as_separate_tests));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  174|      2|  absl::Duration time_limit_per_test = absl::GetFlag(FUZZTEST_FLAG(fuzz_for));
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  175|      2|  if (time_limit_per_test <= absl::ZeroDuration()) {
  ------------------
  |  Branch (175:7): [True: 0, False: 2]
  ------------------
  176|      0|    time_limit_per_test = absl::InfiniteDuration();
  177|      0|  }
  178|      2|  return internal::Configuration{
  179|      2|      absl::GetFlag(FUZZTEST_FLAG(corpus_database)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  180|      2|      std::string(binary_identifier),
  181|      2|      /*fuzz_tests=*/ListRegisteredTests(),
  182|      2|      reproduce_findings_as_separate_tests,
  183|      2|      absl::GetFlag(FUZZTEST_FLAG(replay_coverage_inputs)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  184|      2|      /*stack_limit=*/absl::GetFlag(FUZZTEST_FLAG(stack_limit_kb)) * 1024,
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  185|      2|      /*rss_limit=*/absl::GetFlag(FUZZTEST_FLAG(rss_limit_mb)) * 1024 * 1024,
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  186|      2|      absl::GetFlag(FUZZTEST_FLAG(time_limit_per_input)),
  ------------------
  |  |   20|      2|#define FUZZTEST_FLAG(name) FLAGS_##name
  ------------------
  187|      2|      time_limit_per_test};
  188|      2|}
init_fuzztest.cc:_ZZN8fuzztest19ListRegisteredTestsEvENK3$_0clINS_8internal8FuzzTestEEEDaRKT_:
  127|      4|      [&](const auto& test) { result.push_back(test.full_name()); });

_ZN8fuzztest8internal11CopyableAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  169|  1.18k|      : AnyBase(std::in_place, std::true_type{},
  170|  1.18k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb1EEEPT_:
   34|  1.18k|  explicit AnyBase(std::in_place_t, std::true_type, T* value) {
   35|  1.18k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, CopyImpl<T>};
   36|  1.18k|    vtable_ = &kVTable;
   37|  1.18k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   38|  1.18k|  }
_ZN8fuzztest8internal7AnyBase11DestroyImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEvPv:
  122|  2.36k|  static void DestroyImpl(void* p) {
  123|  2.36k|    delete static_cast<T*>(p);
  124|  2.36k|  }
_ZNR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERT_v:
   58|  1.18k|  T& GetAs() & {
   59|  1.18k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
  ------------------
  |  |   42|  1.18k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 1.18k, False: 0]
  |  |  ------------------
  |  |   43|  1.18k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   60|  1.18k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
  ------------------
  |  |   42|  1.18k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 1.18k, False: 0]
  |  |  ------------------
  |  |   43|  1.18k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   61|  1.18k|    return *static_cast<T*>(value_);
   62|  1.18k|  }
_ZNK8fuzztest8internal7AnyBase9has_valueEv:
   46|  13.0k|  bool has_value() const {
   47|  13.0k|    FUZZTEST_INTERNAL_CHECK((vtable_ == nullptr) == (value_ == nullptr),
  ------------------
  |  |   48|  13.0k|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 13.0k, False: 0]
  |  |  ------------------
  |  |   49|  13.0k|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   48|  13.0k|                            "Inconsistent state between value and vtable.");
   49|  13.0k|    return value_ != nullptr;
   50|  13.0k|  }
_ZNK8fuzztest8internal7AnyBase3HasINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEEbv:
   53|  3.54k|  bool Has() const {
   54|  3.54k|    return has_value() && vtable_->type_id == type_id<T>;
  ------------------
  |  Branch (54:12): [True: 3.54k, False: 0]
  |  Branch (54:27): [True: 3.54k, False: 0]
  ------------------
   55|  3.54k|  }
_ZNKR8fuzztest8internal7AnyBase5GetAsINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEERKT_v:
   65|  2.36k|  const T& GetAs() const& {
   66|  2.36k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(has_value(), "Object is empty!");
  ------------------
  |  |   42|  2.36k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 2.36k, False: 0]
  |  |  ------------------
  |  |   43|  2.36k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   67|  2.36k|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(Has<T>(), "Wrong type!");
  ------------------
  |  |   42|  2.36k|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 2.36k, False: 0]
  |  |  ------------------
  |  |   43|  2.36k|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   68|  2.36k|    return *static_cast<T*>(value_);
   69|  2.36k|  }
_ZN8fuzztest8internal11CopyableAnyC2EOS1_:
  174|  3.54k|  CopyableAny(CopyableAny&& other) = default;
_ZN8fuzztest8internal7AnyBaseC2EOS1_:
   89|  3.54k|      : vtable_(std::exchange(other.vtable_, nullptr)),
   90|  3.54k|        value_(std::exchange(other.value_, nullptr)) {}
_ZN8fuzztest8internal7AnyBaseD2Ev:
  100|  5.91k|  ~AnyBase() { Destroy(); }
_ZN8fuzztest8internal7AnyBase7DestroyEv:
  102|  5.91k|  void Destroy() {
  103|  5.91k|    if (has_value()) vtable_->destroy(value_);
  ------------------
  |  Branch (103:9): [True: 2.36k, False: 3.54k]
  ------------------
  104|  5.91k|  }
_ZN8fuzztest8internal11MoveOnlyAnyC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEJSB_EEENS3_15in_place_type_tIT_EEDpOT0_:
  150|  1.18k|      : AnyBase(std::in_place, std::false_type{},
  151|  1.18k|                new T(std::forward<U>(args)...)) {}
_ZN8fuzztest8internal7AnyBaseC2INSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_10in_place_tENS3_17integral_constantIbLb0EEEPT_:
   40|  1.18k|  explicit AnyBase(std::in_place_t, std::false_type, T* value) {
   41|  1.18k|    static constexpr VTable kVTable = {type_id<T>, DestroyImpl<T>, nullptr};
   42|  1.18k|    vtable_ = &kVTable;
   43|  1.18k|    value_ = const_cast<void*>(static_cast<const void*>(value));
   44|  1.18k|  }

_ZN8fuzztest8internal25SetExternalEngineCallbackEPNS0_22ExternalEngineCallbackE:
   33|      2|void SetExternalEngineCallback(ExternalEngineCallback* callback) {
   34|      2|  external_engine_callback = callback;
   35|      2|}
_ZN8fuzztest8internal25GetExternalEngineCallbackEv:
   37|  4.91k|ExternalEngineCallback* GetExternalEngineCallback() {
   38|  4.91k|  return external_engine_callback;
   39|  4.91k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptorC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE:
   66|      2|    : test_(test), fixture_driver_staging_(std::move(fixture_driver)) {}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationE:
   74|      2|    int* argc, char*** argv, const Configuration& configuration) {
   75|      2|  FUZZTEST_INTERNAL_CHECK(&LLVMFuzzerRunDriver,
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, Folded]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   76|      2|                          "LibFuzzer Driver API not defined.");
   77|      2|  FUZZTEST_INTERNAL_CHECK(
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   78|      2|      GetExternalEngineCallback() == nullptr,
   79|      2|      "External engine callback is already set while running a fuzz test.");
   80|      2|  SetExternalEngineCallback(this);
   81|      2|  runtime_.SetRunMode(RunMode::kFuzz);
   82|      2|  auto& impl = GetFuzzerImpl();
   83|      2|  runtime_.EnableReporter(&impl.stats_, [] { return absl::Now(); });
   84|       |
   85|      2|  FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr,
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   86|      2|                          "Invalid fixture driver!");
   87|      2|  impl.fixture_driver_->SetUpFuzzTest();
   88|       |
   89|      2|  static bool driver_started = false;
   90|      2|  FUZZTEST_INTERNAL_CHECK(!driver_started, "Driver started more than once!");
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
   91|      2|  driver_started = true;
   92|      2|  LLVMFuzzerRunDriver(argc, argv, [](const uint8_t* data, size_t size) -> int {
   93|      2|    GetExternalEngineCallback()->RunOneInputData(
   94|      2|        absl::string_view(reinterpret_cast<const char*>(data), size));
   95|      2|    return 0;
   96|      2|  });
   97|       |
   98|       |  // If we're here, we didn't exit from RunOneInputData(), and hence we didn't
   99|       |  // tear down the fixture.
  100|      2|  FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr,
  ------------------
  |  |   48|      2|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 0, False: 2]
  |  |  ------------------
  |  |   49|      2|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      2|                __FILE__, __LINE__,                            \
  |  |   51|      2|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      2|                             ") failed: ", __VA_ARGS__)))
  ------------------
  101|      2|                          "Invalid fixture driver!");
  102|      2|  impl.fixture_driver_->TearDownFuzzTest();
  103|       |
  104|      2|  return 0;
  105|      2|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor15RunOneInputDataENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  117|  4.91k|void FuzzTestExternalEngineAdaptor::RunOneInputData(absl::string_view data) {
  118|  4.91k|  auto& impl = GetFuzzerImpl();
  119|  4.91k|  if (impl.ShouldStop()) {
  ------------------
  |  Branch (119:7): [True: 0, False: 4.91k]
  ------------------
  120|      0|    FUZZTEST_INTERNAL_CHECK(impl.fixture_driver_ != nullptr,
  ------------------
  |  |   48|      0|  ((cond) ? (void)0                                            \
  |  |  ------------------
  |  |  |  Branch (48:4): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|          : ::fuzztest::internal::Abort(                       \
  |  |   50|      0|                __FILE__, __LINE__,                            \
  |  |   51|      0|                absl::StrCat("Internal error! Check (", #cond, \
  |  |   52|      0|                             ") failed: ", __VA_ARGS__)))
  ------------------
  121|      0|                            "Invalid fixture driver!");
  122|      0|    impl.fixture_driver_->TearDownFuzzTest();
  123|      0|    runtime_.PrintFinalStatsOnDefaultSink();
  124|       |    // Use _Exit instead of exit so libFuzzer does not treat it as a crash.
  125|      0|    std::_Exit(0);
  126|      0|  }
  127|  4.91k|  runtime_.SetCurrentTest(&impl.test_, nullptr);
  128|  4.91k|  if (data.size() == 0) return;
  ------------------
  |  Branch (128:7): [True: 0, False: 4.91k]
  ------------------
  129|  4.91k|  auto input = impl.TryParse(data);
  130|  4.91k|  if (!input) return;
  ------------------
  |  Branch (130:7): [True: 3.73k, False: 1.18k]
  ------------------
  131|  1.18k|  impl.RunOneInput({*std::move(input)});
  132|  1.18k|}
_ZN8fuzztest8internal29FuzzTestExternalEngineAdaptor13GetFuzzerImplEv:
  160|  4.91k|FuzzTestExternalEngineAdaptor::GetFuzzerImpl() {
  161|       |  // Postpone the creation to override libFuzzer signal setup.
  162|  4.91k|  if (!fuzzer_impl_) {
  ------------------
  |  Branch (162:7): [True: 2, False: 4.91k]
  ------------------
  163|      2|    fuzzer_impl_ =
  164|      2|        std::make_unique<FuzzerImpl>(test_, std::move(fixture_driver_staging_));
  165|      2|    fixture_driver_staging_ = nullptr;
  166|      2|  }
  167|  4.91k|  return *fuzzer_impl_;
  168|  4.91k|}
compatibility_mode.cc:_ZZN8fuzztest8internal29FuzzTestExternalEngineAdaptor16RunInFuzzingModeEPiPPPcRKNS0_13ConfigurationEENK3$_1clEPKhm:
   92|  4.91k|  LLVMFuzzerRunDriver(argc, argv, [](const uint8_t* data, size_t size) -> int {
   93|  4.91k|    GetExternalEngineCallback()->RunOneInputData(
   94|  4.91k|        absl::string_view(reinterpret_cast<const char*>(data), size));
   95|  4.91k|    return 0;
   96|  4.91k|  });

_ZN8fuzztest8internal14CorpusDatabaseC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_bb:
   44|      2|    : corpus_path_for_test_binary_([=] () -> std::string {
   45|      2|        if (database_path.empty()) return "";
   46|      2|        std::string corpus_path_for_test_binary =
   47|      2|            absl::StrCat(database_path, "/", binary_identifier);
   48|      2|        if (!absl::StartsWith(corpus_path_for_test_binary, "/") &&
   49|      2|            std::getenv("TEST_SRCDIR")) {
   50|      2|          corpus_path_for_test_binary = absl::StrCat(
   51|      2|              std::getenv("TEST_SRCDIR"), "/", corpus_path_for_test_binary);
   52|      2|        }
   53|      2|        return corpus_path_for_test_binary;
   54|      2|      }()),
   55|      2|      use_coverage_inputs_(use_coverage_inputs),
   56|      2|      use_crashing_inputs_(use_crashing_inputs) {}
_ZN8fuzztest8internal14CorpusDatabaseC2ERKNS0_13ConfigurationE:
   59|      2|    : CorpusDatabase(
   60|      2|          configuration.corpus_database, configuration.binary_identifier,
   61|      2|          /*use_coverage_inputs=*/configuration.replay_coverage_inputs,
   62|       |          /*use_crashing_inputs=*/
   63|      2|          configuration.reproduce_findings_as_separate_tests) {}
_ZNK8fuzztest8internal14CorpusDatabase22GetCrashingInputsIfAnyENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   71|      2|    absl::string_view test_name) const {
   72|      2|  if (!use_crashing_inputs_) return {};
  ------------------
  |  Branch (72:7): [True: 2, False: 0]
  ------------------
   73|      0|  return GetInputs(corpus_path_for_test_binary_, test_name, "crashing");
   74|      2|}
corpus_database.cc:_ZZN8fuzztest8internal14CorpusDatabaseC1ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_bbENK3$_0clEv:
   44|      2|    : corpus_path_for_test_binary_([=] () -> std::string {
   45|      2|        if (database_path.empty()) return "";
  ------------------
  |  Branch (45:13): [True: 0, False: 2]
  ------------------
   46|      2|        std::string corpus_path_for_test_binary =
   47|      2|            absl::StrCat(database_path, "/", binary_identifier);
   48|      2|        if (!absl::StartsWith(corpus_path_for_test_binary, "/") &&
  ------------------
  |  Branch (48:13): [True: 2, False: 0]
  ------------------
   49|      2|            std::getenv("TEST_SRCDIR")) {
  ------------------
  |  Branch (49:13): [True: 0, False: 2]
  ------------------
   50|      0|          corpus_path_for_test_binary = absl::StrCat(
   51|      0|              std::getenv("TEST_SRCDIR"), "/", corpus_path_for_test_binary);
   52|      0|        }
   53|      2|        return corpus_path_for_test_binary;
   54|      2|      }()),

_ZN8fuzztest8internal20GetExecutionCoverageEv:
   86|      2|ExecutionCoverage* GetExecutionCoverage() {
   87|      2|  return execution_coverage_instance;
   88|      2|}
_ZN8fuzztest8internal14CorpusCoverageC2Em:
  264|      2|CorpusCoverage::CorpusCoverage(size_t map_size) {
  265|      2|  size_t alignment = alignof(Vector);
  266|       |  // Round up to a multiple of alignment.
  267|      2|  map_size += alignment - 1;
  268|      2|  map_size -= map_size % alignment;
  269|       |  // And allocate an extra step to make sure the alignment logic has the
  270|       |  // necessary space.
  271|      2|  map_size += alignment;
  272|      2|  corpus_map_size_ = map_size;
  273|      2|  corpus_map_ = static_cast<uint8_t*>(std::aligned_alloc(alignment, map_size));
  274|      2|  std::fill(corpus_map_, corpus_map_ + corpus_map_size_, 0);
  275|      2|}

_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_:
  166|  1.18k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  167|  1.18k|    absl::Status result = absl::OkStatus();
  168|  1.18k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  169|  1.18k|      (
  170|  1.18k|          [&] {
  171|  1.18k|            if (!result.ok()) return;
  172|  1.18k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  1.18k|                std::get<I>(corpus_value));
  174|  1.18k|            result = Prefix(s, "Invalid value in aggregate");
  175|  1.18k|          }(),
  176|  1.18k|          ...);
  177|  1.18k|    });
  178|  1.18k|    return result;
  179|  1.18k|  }
_ZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_:
  168|  1.18k|    ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  169|  1.18k|      (
  170|  1.18k|          [&] {
  171|  1.18k|            if (!result.ok()) return;
  172|  1.18k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  1.18k|                std::get<I>(corpus_value));
  174|  1.18k|            result = Prefix(s, "Invalid value in aggregate");
  175|  1.18k|          }(),
  176|  1.18k|          ...);
  177|  1.18k|    });
_ZZZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSA_ENKUlDpT_E_clIJNS2_17integral_constantImLm0EEEEEEDaSK_ENKUlvE_clEv:
  170|  1.18k|          [&] {
  171|  1.18k|            if (!result.ok()) return;
  ------------------
  |  Branch (171:17): [True: 0, False: 1.18k]
  ------------------
  172|  1.18k|            const absl::Status s = std::get<I>(inner_).ValidateCorpusValue(
  173|  1.18k|                std::get<I>(corpus_value));
  174|  1.18k|            result = Prefix(s, "Invalid value in aggregate");
  175|  1.18k|          }(),
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE11ParseCorpusERKNS0_8IRObjectE:
  150|  3.32k|  std::optional<corpus_type> ParseCorpus(const IRObject& obj) const {
  151|       |    if constexpr (has_custom_corpus_type) {
  152|       |      return ParseWithDomainTuple(inner_, obj);
  153|  3.32k|    } else {
  154|  3.32k|      return obj.ToCorpus<corpus_type>();
  155|  3.32k|    }
  156|  3.32k|  }
_ZNK8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEE8GetValueERKSA_:
  108|  1.18k|  value_type GetValue(const corpus_type& value) const {
  109|       |    if constexpr (has_custom_corpus_type) {
  110|       |      if constexpr (DetectBindableFieldCount<value_type>() ==
  111|       |                    DetectBraceInitCount<value_type>()) {
  112|       |        return ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  113|       |          return T{std::get<I>(inner_).GetValue(std::get<I>(value))...};
  114|       |        });
  115|       |      } else {
  116|       |        // Right now the only other possibility is that the bindable field count
  117|       |        // is one less than the brace init field count. In that case, that extra
  118|       |        // field is used to initialize an empty base class. We'll need to update
  119|       |        // this if that ever changes.
  120|       |        return ApplyIndex<sizeof...(Inner)>([&](auto... I) {
  121|       |          return T{{}, std::get<I>(inner_).GetValue(std::get<I>(value))...};
  122|       |        });
  123|       |      }
  124|  1.18k|    } else {
  125|  1.18k|      return value;
  126|  1.18k|    }
  127|  1.18k|  }
_ZN8fuzztest8internal15AggregateOfImplINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplIS9_NS0_13ArbitraryImplIcvEEEEEEC2ENS2_10in_place_tESF_:
   58|      2|      : inner_(std::move(inner)...) {}

_ZNK8fuzztest8internal13ArbitraryImplIcvE19ValidateCorpusValueERKc:
  189|  10.0M|  absl::Status ValidateCorpusValue(const value_type&) const {
  190|  10.0M|    return absl::OkStatus();  // Nothing to validate.
  191|  10.0M|  }

_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE19ValidateCorpusValueERKS9_:
  319|  1.18k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  320|       |    // Check size.
  321|  1.18k|    if (corpus_value.size() < min_size()) {
  ------------------
  |  Branch (321:9): [True: 0, False: 1.18k]
  ------------------
  322|      0|      return absl::InvalidArgumentError(absl::StrCat(
  323|      0|          "Invalid size: ", corpus_value.size(), ". Min size: ", min_size()));
  324|      0|    }
  325|  1.18k|    if (corpus_value.size() > max_size()) {
  ------------------
  |  Branch (325:9): [True: 0, False: 1.18k]
  ------------------
  326|      0|      return absl::InvalidArgumentError(absl::StrCat(
  327|      0|          "Invalid size: ", corpus_value.size(), ". Max size: ", max_size()));
  328|      0|    }
  329|       |    // Check elements.
  330|  1.18k|    int i = 0;
  331|  10.0M|    for (const auto& elem : corpus_value) {
  ------------------
  |  Branch (331:27): [True: 10.0M, False: 1.18k]
  ------------------
  332|  10.0M|      const absl::Status s = inner_.ValidateCorpusValue(elem);
  333|  10.0M|      if (!s.ok()) {
  ------------------
  |  Branch (333:11): [True: 0, False: 10.0M]
  ------------------
  334|      0|        return Prefix(s,
  335|      0|                      absl::StrCat("Invalid value in container at index ", i));
  336|      0|      }
  337|  10.0M|      i++;
  338|  10.0M|    }
  339|  1.18k|    return absl::OkStatus();
  340|  1.18k|  }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE8min_sizeEv:
  371|  1.18k|  size_t min_size() const { return min_size_; }
_ZNK8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE8max_sizeEv:
  372|  1.18k|  size_t max_size() const {
  373|  1.18k|    return max_size_.value_or(std::max(min_size_, kDefaultContainerMaxSize));
  374|  1.18k|  }
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE4SelfEv:
  377|      2|  Derived& Self() { return static_cast<Derived&>(*this); }
_ZN8fuzztest8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEC2Ev:
  534|      2|  SequenceContainerOfImpl() = default;
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEEC2Ev:
  112|      2|  ContainerOfImplBase() = default;
_ZN8fuzztest8internal19ContainerOfImplBaseINS0_23SequenceContainerOfImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEE11WithMaxSizeEm:
  224|      2|  Derived& WithMaxSize(size_t s) {
  225|      2|    FUZZTEST_INTERNAL_CHECK_PRECONDITION(
  ------------------
  |  |   42|      2|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   43|      2|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
  226|      2|        min_size_ <= s, "Maximal size ", s,
  227|      2|        " cannot be smaller than minimal size ", min_size_);
  228|      2|    max_size_ = s;
  229|      2|    return Self();
  230|      2|  }

_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEC2INS_8internal15AggregateOfImplIS9_LNSC_23RequireCustomCorpusTypeE0EJNSC_23SequenceContainerOfImplIS8_NSC_13ArbitraryImplIcvEEEEEEES9_EEONS_18domain_implementor10DomainBaseIT_S9_T0_EE:
  108|      2|      : inner_(std::make_unique<internal::DomainModel<Inner>>(
  109|      2|            static_cast<Inner&&>(inner))) {}
_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEC2ERKSA_:
  111|     12|  Domain(const Domain& other) { *this = other; }
_ZN8fuzztest6DomainINSt3__15tupleIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEEaSERKSA_:
  112|     12|  Domain& operator=(const Domain& other) {
  113|     12|    inner_ = other.inner_->TypedClone();
  114|     12|    return *this;
  115|     12|  }
_ZN8fuzztest13UntypedDomainC2INSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEEERKNS_6DomainIT_EE:
  301|      2|      : inner_(domain.inner_->UntypedClone()) {}
_ZNK8fuzztest13UntypedDomain8GetValueERKNS_8internal11CopyableAnyE:
  310|  1.18k|  value_type GetValue(const corpus_type& corpus_value) const {
  311|  1.18k|    return inner_->UntypedGetValue(corpus_value);
  312|  1.18k|  }
_ZNK8fuzztest13UntypedDomain11ParseCorpusERKNS_8internal8IRObjectE:
  314|  3.32k|  std::optional<corpus_type> ParseCorpus(const internal::IRObject& obj) const {
  315|  3.32k|    return inner_->UntypedParseCorpus(obj);
  316|  3.32k|  }
_ZNK8fuzztest13UntypedDomain19ValidateCorpusValueERKNS_8internal11CopyableAnyE:
  322|  1.18k|  absl::Status ValidateCorpusValue(const corpus_type& corpus_value) const {
  323|  1.18k|    return inner_->UntypedValidateCorpusValue(corpus_value);
  324|  1.18k|  }

_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal15AggregateOfImplINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEELNS2_23RequireCustomCorpusTypeE0EJNS2_23SequenceContainerOfImplISB_NS2_13ArbitraryImplIcvEEEEEEESC_SC_EC2Ev:
  114|      2|  DomainBase() {
  115|       |    // Check that the interface of `Derived` matches the requirements for a
  116|       |    // domain implementation. We check these inside the constructor of
  117|       |    // `DomainBase`, where `Derived` is already fully defined. If we try to
  118|       |    // check them at class scope we would see an incomplete `Derived` class and
  119|       |    // the checks would not work.
  120|      2|    fuzztest::internal::CheckIsSame<
  121|      2|        ValueType, fuzztest::internal::value_type_t<Derived>>();
  122|      2|    fuzztest::internal::CheckIsSame<
  123|      2|        CorpusType, fuzztest::internal::corpus_type_t<Derived>>();
  124|      2|    static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type);
  125|       |
  126|       |    // Check that `Derived` type-checks against the type-erased `Domain<T>`
  127|       |    // interface by forcing the `DomainModel` template specialization.
  128|      2|    if (Derived* domain = nullptr) {
  ------------------
  |  Branch (128:18): [True: 0, False: 2]
  ------------------
  129|      0|      (void)fuzztest::internal::DomainModel<Derived>{*domain};
  130|      0|    }
  131|      2|  }
_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal23SequenceContainerOfImplINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS2_13ArbitraryImplIcvEEEESA_SA_EC2Ev:
  114|      2|  DomainBase() {
  115|       |    // Check that the interface of `Derived` matches the requirements for a
  116|       |    // domain implementation. We check these inside the constructor of
  117|       |    // `DomainBase`, where `Derived` is already fully defined. If we try to
  118|       |    // check them at class scope we would see an incomplete `Derived` class and
  119|       |    // the checks would not work.
  120|      2|    fuzztest::internal::CheckIsSame<
  121|      2|        ValueType, fuzztest::internal::value_type_t<Derived>>();
  122|      2|    fuzztest::internal::CheckIsSame<
  123|      2|        CorpusType, fuzztest::internal::corpus_type_t<Derived>>();
  124|      2|    static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type);
  125|       |
  126|       |    // Check that `Derived` type-checks against the type-erased `Domain<T>`
  127|       |    // interface by forcing the `DomainModel` template specialization.
  128|      2|    if (Derived* domain = nullptr) {
  ------------------
  |  Branch (128:18): [True: 0, False: 2]
  ------------------
  129|      0|      (void)fuzztest::internal::DomainModel<Derived>{*domain};
  130|      0|    }
  131|      2|  }
_ZN8fuzztest18domain_implementor10DomainBaseINS_8internal13ArbitraryImplIcvEEccEC2Ev:
  114|      2|  DomainBase() {
  115|       |    // Check that the interface of `Derived` matches the requirements for a
  116|       |    // domain implementation. We check these inside the constructor of
  117|       |    // `DomainBase`, where `Derived` is already fully defined. If we try to
  118|       |    // check them at class scope we would see an incomplete `Derived` class and
  119|       |    // the checks would not work.
  120|      2|    fuzztest::internal::CheckIsSame<
  121|      2|        ValueType, fuzztest::internal::value_type_t<Derived>>();
  122|      2|    fuzztest::internal::CheckIsSame<
  123|      2|        CorpusType, fuzztest::internal::corpus_type_t<Derived>>();
  124|      2|    static_assert(has_custom_corpus_type == Derived::has_custom_corpus_type);
  125|       |
  126|       |    // Check that `Derived` type-checks against the type-erased `Domain<T>`
  127|       |    // interface by forcing the `DomainModel` template specialization.
  128|      2|    if (Derived* domain = nullptr) {
  ------------------
  |  Branch (128:18): [True: 0, False: 2]
  ------------------
  129|      0|      (void)fuzztest::internal::DomainModel<Derived>{*domain};
  130|      0|    }
  131|      2|  }

_ZN8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEEC2EOSH_:
  126|      2|  explicit DomainModel(D&& domain) : domain_(std::forward<D>(domain)) {}
_ZN8fuzztest8internal20UntypedDomainConceptD2Ev:
   55|     10|  virtual ~UntypedDomainConcept() = default;
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE12UntypedCloneEv:
  104|      2|  std::unique_ptr<UntypedDomainConcept> UntypedClone() const final {
  105|      2|    return TypedClone();
  106|      2|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE18UntypedParseCorpusERKNS0_8IRObjectE:
  165|  3.32k|      const IRObject& obj) const final {
  166|  3.32k|    if (auto res = domain_.ParseCorpus(obj)) {
  ------------------
  |  Branch (166:14): [True: 1.18k, False: 2.14k]
  ------------------
  167|  1.18k|      return GenericDomainCorpusType(std::in_place_type<CorpusType>,
  168|  1.18k|                                     *std::move(res));
  169|  2.14k|    } else {
  170|  2.14k|      return std::nullopt;
  171|  2.14k|    }
  172|  3.32k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE26UntypedValidateCorpusValueERKNS0_11CopyableAnyE:
  180|  1.18k|      const GenericDomainCorpusType& corpus_value) const final {
  181|  1.18k|    return domain_.ValidateCorpusValue(corpus_value.GetAs<CorpusType>());
  182|  1.18k|  }
_ZNK8fuzztest8internal18TypedDomainConceptINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEE15UntypedGetValueERKNS0_11CopyableAnyE:
  109|  1.18k|      const GenericDomainCorpusType& v) const final {
  110|  1.18k|    return GenericDomainValueType(std::in_place_type<ValueType>,
  111|  1.18k|                                  TypedGetValue(v));
  112|  1.18k|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE10TypedCloneEv:
  128|     14|  std::unique_ptr<TypedDomainConcept<ValueType>> TypedClone() const final {
  129|     14|    return std::make_unique<DomainModel>(*this);
  130|     14|  }
_ZNK8fuzztest8internal11DomainModelINS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEEEE13TypedGetValueERKNS0_11CopyableAnyE:
  150|  1.18k|  ValueType TypedGetValue(const GenericDomainCorpusType& v) const final {
  151|  1.18k|    return domain_.GetValue(v.GetAs<CorpusType>());
  152|  1.18k|  }

_ZN8fuzztest8internal20UntypedFixtureDriver13SetUpFuzzTestEv:
   20|      2|void UntypedFixtureDriver::SetUpFuzzTest() {}
_ZN8fuzztest8internal20UntypedFixtureDriver14SetUpIterationEv:
   21|  1.18k|void UntypedFixtureDriver::SetUpIteration() {}
_ZN8fuzztest8internal20UntypedFixtureDriver17TearDownIterationEv:
   22|  1.18k|void UntypedFixtureDriver::TearDownIteration() {}

_ZN8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvEC2ESH_SC_NS3_6vectorINS0_11CopyableAnyENS8_ISL_EEEERKSI_:
  287|      2|      : FixtureDriver::TypedFixtureDriver(std::move(domain), std::move(seeds),
  288|      2|                                          seed_provider),
  289|      2|        target_function_(target_function) {}
_ZN8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEPvEC2ENS_6DomainISA_EENS2_6vectorINS0_11CopyableAnyENS7_ISG_EEEERKSB_:
  104|      2|      : domain_(std::move(domain)),
  105|      2|        seeds_(std::move(seeds)),
  106|      2|        seed_provider_(seed_provider) {}
_ZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyE:
  291|  1.18k|  void Test(MoveOnlyAny&& args_untyped) const override {
  292|  1.18k|    std::apply(
  293|  1.18k|        [&](auto&&... args) {
  294|  1.18k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  295|  1.18k|        },
  296|  1.18k|        args_untyped.GetAs<value_type_t<DomainT>>());
  297|  1.18k|  }
_ZZNK8fuzztest8internal13FixtureDriverINS_6DomainINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS0_9NoFixtureEPFvNS3_17basic_string_viewIcS7_EEEPvE4TestEONS0_11MoveOnlyAnyEENKUlDpOT_E_clIJRSA_EEEDaSO_:
  293|  1.18k|        [&](auto&&... args) {
  294|  1.18k|          target_function_(ForceVectorForStringView<Args>(std::move(args))...);
  295|  1.18k|        },
_ZN8fuzztest8internal24ForceVectorForStringViewINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEEDcOT0_:
  181|  1.18k|decltype(auto) ForceVectorForStringView(Src&& src) {
  182|       |  // We only do this when Src is a std::string. If it's a string view it is
  183|       |  // handled by the string view domain itself.
  184|       |  if constexpr (std::is_same_v<void(std::decay_t<Dest>, std::decay_t<Src>),
  185|  1.18k|                               void(std::string_view, std::string)>) {
  186|  1.18k|    return ForceVector{std::vector<char>(src.begin(), src.end())};
  187|       |  } else {
  188|       |    return std::forward<Src>(src);
  189|       |  }
  190|  1.18k|}
_ZNK8fuzztest8internal11ForceVectorcvNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEv:
  176|  1.18k|  operator std::string_view() const { return {value.data(), value.size()}; }
_ZNK8fuzztest8internal18TypedFixtureDriverINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEEPvE10GetDomainsEv:
  120|      2|  UntypedDomain GetDomains() const final { return domain_; }

_ZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationE:
   64|      2|                                    const Configuration& configuration) {
   65|      2|  ::fuzztest::internal::ForEachTest([&](auto& test) {
   66|      2|    if (test.uses_fixture()) {
   67|      2|      RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test,
   68|      2|                                                             configuration);
   69|      2|    } else {
   70|      2|      RegisterTests<::testing::Test>(argc, argv, test, configuration);
   71|      2|    }
   72|      2|  });
   73|       |
   74|      2|  ::testing::UnitTest::GetInstance()->listeners().Append(
   75|      2|      new ::fuzztest::internal::GTest_EventListener<
   76|      2|          ::testing::EmptyTestEventListener, ::testing::TestPartResult>());
   77|      2|}
_ZN8fuzztest8internal28FuzzTestListingModeValidator26RegisterGoogleTestListenerEv:
  133|      2|void FuzzTestListingModeValidator::RegisterGoogleTestListener() {
  134|      2|  testing::UnitTest::GetInstance()->listeners().Append(
  135|      2|      new ValidatorProxyListener(this));
  136|      2|}
_ZN8fuzztest8internal44SetFuzzTestListingModeValidatorForGoogleTestEb:
  138|      2|void SetFuzzTestListingModeValidatorForGoogleTest(bool listing_mode) {
  139|      2|  FuzzTestListingModeValidator::GetInstance().set_listing_mode(listing_mode);
  140|      2|}
_ZN8fuzztest8internal22ValidatorProxyListenerC2EPNS0_28FuzzTestListingModeValidatorE:
  128|      2|      : validator_(validator) {}
_ZN8fuzztest8internal22ValidatorProxyListener18OnTestProgramStartERKN7testing8UnitTestE:
  120|      2|  void OnTestProgramStart(const testing::UnitTest& unit_test) override {
  121|      2|    validator_->Run();
  122|      2|  }
_ZN8fuzztest8internal28FuzzTestListingModeValidator3RunEv:
   83|      2|  void Run() {
   84|      2|    if (listing_mode_) {
  ------------------
  |  Branch (84:9): [True: 0, False: 2]
  ------------------
   85|       |      // Since InitFuzzTest calls std::exit after listing the fuzz tests, we
   86|       |      // would not reach here if InitFuzzTest is called before.
   87|       |      absl::FPrintF(stderr,
   88|      0|                    "[!] --" FUZZTEST_FLAG_PREFIX
   89|      0|                    "list_fuzz_tests not handled by InitFuzzTest - fuzz tests "
   90|      0|                    "would not be listed even if defined.\n");
   91|      0|      std::exit(0);
   92|      0|    }
   93|      2|  }
_ZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEv:
   97|      2|  static FuzzTestListingModeValidator& GetInstance() {
   98|      2|    static auto* instance = [] {
   99|      2|      static_assert(
  100|      2|          std::is_trivially_destructible_v<FuzzTestListingModeValidator>);
  101|      2|      static FuzzTestListingModeValidator instance;
  102|      2|      instance.RegisterGoogleTestListener();
  103|      2|      return &instance;
  104|      2|    }();
  105|      2|    return *instance;
  106|      2|  }
_ZZN8fuzztest8internal28FuzzTestListingModeValidator11GetInstanceEvENKUlvE_clEv:
   98|      2|    static auto* instance = [] {
   99|      2|      static_assert(
  100|      2|          std::is_trivially_destructible_v<FuzzTestListingModeValidator>);
  101|      2|      static FuzzTestListingModeValidator instance;
  102|      2|      instance.RegisterGoogleTestListener();
  103|      2|      return &instance;
  104|      2|    }();
_ZN8fuzztest8internal28FuzzTestListingModeValidator16set_listing_modeEb:
   95|      2|  void set_listing_mode(bool listing_mode) { listing_mode_ = listing_mode; }
googletest_adaptor.cc:_ZZN8fuzztest8internal30RegisterFuzzTestsAsGoogleTestsEPiPPPcRKNS0_13ConfigurationEENK3$_0clINS0_8FuzzTestEEEDaRT_:
   65|      2|  ::fuzztest::internal::ForEachTest([&](auto& test) {
   66|      2|    if (test.uses_fixture()) {
  ------------------
  |  Branch (66:9): [True: 0, False: 2]
  ------------------
   67|      0|      RegisterTests<::fuzztest::internal::GTest_TestAdaptor>(argc, argv, test,
   68|      0|                                                             configuration);
   69|      2|    } else {
   70|      2|      RegisterTests<::testing::Test>(argc, argv, test, configuration);
   71|      2|    }
   72|      2|  });
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_113RegisterTestsIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE:
   55|      2|                   const Configuration& configuration) {
   56|      2|  RegisterFuzzTestAsGTest<T>(argc, argv, test, configuration);
   57|      2|  RegisterSeparateRegressionTestForEachCrashingInput<T>(argc, argv, test,
   58|      2|                                                        configuration);
   59|      2|}
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEE:
   25|      2|                             absl::string_view suffix = "") {
   26|      2|  auto fixture_factory = [argc, argv, &test,
   27|      2|                          configuration = configuration]() -> T* {
   28|      2|    return new ::fuzztest::internal::GTest_TestAdaptor(test, argc, argv,
   29|      2|                                                       configuration);
   30|      2|  };
   31|      2|  const std::string test_name_with_suffix =
   32|      2|      absl::StrCat(test.test_name(), suffix);
   33|      2|  ::testing::RegisterTest(
   34|      2|      test.suite_name().c_str(), test_name_with_suffix.c_str(), nullptr,
   35|      2|      nullptr, test.file().c_str(), test.line(), std::move(fixture_factory));
   36|      2|}
googletest_adaptor.cc:_ZZN8fuzztest8internal12_GLOBAL__N_123RegisterFuzzTestAsGTestIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationENSt3__117basic_string_viewIcNSE_11char_traitsIcEEEEENKUlvE_clEv:
   27|      2|                          configuration = configuration]() -> T* {
   28|      2|    return new ::fuzztest::internal::GTest_TestAdaptor(test, argc, argv,
   29|      2|                                                       configuration);
   30|      2|  };
googletest_adaptor.cc:_ZN8fuzztest8internal12_GLOBAL__N_150RegisterSeparateRegressionTestForEachCrashingInputIN7testing4TestEEEvPiPPPcRNS0_8FuzzTestERKNS0_13ConfigurationE:
   41|      2|    const Configuration& configuration) {
   42|      2|  CorpusDatabase corpus_database(configuration);
   43|      2|  for (const std::string& input :
  ------------------
  |  Branch (43:33): [True: 0, False: 2]
  ------------------
   44|      2|       corpus_database.GetCrashingInputsIfAny(test.full_name())) {
   45|      0|    Configuration updated_configuration = configuration;
   46|      0|    updated_configuration.crashing_input_to_reproduce = input;
   47|      0|    const std::string suffix =
   48|      0|        absl::StrCat("/Regression/", std::string(Basename(input)));
   49|      0|    RegisterFuzzTestAsGTest<T>(argc, argv, test, updated_configuration, suffix);
   50|      0|  }
   51|      2|}

_ZN8fuzztest8internal17GTest_TestAdaptorC2ERNS0_8FuzzTestEPiPPPcNS0_13ConfigurationE:
   33|      2|      : test_(test),
   34|      2|        argc_(argc),
   35|      2|        argv_(argv),
   36|      2|        configuration_(std::move(configuration)) {}
_ZN8fuzztest8internal17GTest_TestAdaptor8TestBodyEv:
   38|      2|  void TestBody() override {
   39|      2|    auto test = test_.make();
   40|      2|    if (Runtime::instance().run_mode() == RunMode::kUnitTest) {
  ------------------
  |  Branch (40:9): [True: 0, False: 2]
  ------------------
   41|       |      // In "bug reproduction" mode, sometimes we need to reproduce multiple
   42|       |      // bugs, i.e., run multiple tests that lead to a crash.
   43|      0|      bool needs_subprocess = false;
   44|      0|#ifdef GTEST_HAS_DEATH_TEST
   45|      0|      needs_subprocess =
   46|      0|          configuration_.crashing_input_to_reproduce.has_value() &&
  ------------------
  |  Branch (46:11): [True: 0, False: 0]
  ------------------
   47|      0|          (
   48|       |              // When only a single test runs, it's okay to crash the process on
   49|       |              // error, as we don't need to run other tests.
   50|      0|              testing::UnitTest::GetInstance()->test_to_run_count() > 1 ||
  ------------------
  |  Branch (50:15): [True: 0, False: 0]
  ------------------
   51|       |              // EXPECT_EXIT is required in the death-test subprocess, but in
   52|       |              // the subprocess there's only one test to run.
   53|      0|              testing::internal::InDeathTestChild());
  ------------------
  |  Branch (53:15): [True: 0, False: 0]
  ------------------
   54|      0|#endif
   55|      0|      if (needs_subprocess) {
  ------------------
  |  Branch (55:11): [True: 0, False: 0]
  ------------------
   56|      0|        configuration_.preprocess_crash_reproducing = [] {
   57|       |          // EXPECT_EXIT disables event forwarding in gtest and as a result,
   58|       |          // EXPECT/ASSERT-s are disabled. Here, we overwrite this option.
   59|      0|          testing::UnitTest::GetInstance()->listeners().SuppressEventForwarding(
   60|      0|              false);
   61|      0|        };
   62|       |        // `RunInUnitTestMode` is supposed to fail and we wish to show the
   63|       |        // failure to the user. Directly running the test would terminate the
   64|       |        // process and using `EXPECT_DEATH` causes the test to pass. We use
   65|       |        // `EXPECT_EXIT` so that the test exit unsuccessfully, meaning that the
   66|       |        // test below fails without terminating the process.
   67|      0|#ifdef GTEST_HAS_DEATH_TEST
   68|      0|        EXPECT_EXIT(
  ------------------
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  |  Branch (68:9): [True: 0, False: 0]
  ------------------
   69|      0|            (test->RunInUnitTestMode(configuration_),
   70|      0|             void(
   71|      0|                 R"( FuzzTest failure! Please see 'actual message' below for the crash report. )"),
   72|      0|             std::exit(0)),
   73|      0|            ::testing::ExitedWithCode(0), "");
   74|       |#else
   75|       |        EXPECT_TRUE(false) << "Death test is not supported.";
   76|       |#endif
   77|      0|      } else {
   78|      0|        test->RunInUnitTestMode(configuration_);
   79|      0|      }
   80|      2|    } else {
   81|       |      // TODO(b/245753736): Consider using `tolerate_failure` when FuzzTest can
   82|       |      // tolerate crashes in fuzzing mode.
   83|      6|      ASSERT_EQ(0, test->RunInFuzzingMode(argc_, argv_, configuration_))
  ------------------
  |  Branch (83:7): [True: 0, False: 2]
  |  Branch (83:7): [True: 0, False: 2]
  |  Branch (83:7): [True: 2, False: 0]
  ------------------
   84|      6|          << "Fuzzing failure.";
   85|      2|    }
   86|      2|  }

_ZN8fuzztest8internal8BasenameENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  186|      2|absl::string_view Basename(absl::string_view filename) {
  187|      2|  auto last_slash_pos = filename.find_last_of("/\\");
  188|       |
  189|      2|  return last_slash_pos == absl::string_view::npos
  ------------------
  |  Branch (189:10): [True: 0, False: 2]
  ------------------
  190|      2|             ? filename
  191|      2|             : filename.substr(last_slash_pos + 1);
  192|      2|}

_ZN8fuzztest8internal9GetStderrEv:
  125|  3.73k|FILE* GetStderr() {
  126|  3.73k|  absl::MutexLock lock(&stderr_file_guard_);
  127|  3.73k|  if (!stderr_file_) {
  ------------------
  |  Branch (127:7): [True: 2, False: 3.73k]
  ------------------
  128|       |    stderr_file_ = stderr;
  129|      2|  }
  130|  3.73k|  return stderr_file_;
  131|  3.73k|}

_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_:
   54|  1.18k|constexpr auto ApplyIndex(F f) {
   55|  1.18k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  1.18k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_15AggregateOfImplINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEELNS0_23RequireCustomCorpusTypeE0EJNS0_23SequenceContainerOfImplISA_NS0_13ArbitraryImplIcvEEEEEE19ValidateCorpusValueERKSB_EUlDpT_E_EEDaT0_NS3_16integer_sequenceImJXspT_EEEE:
   39|  1.18k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  1.18k|  return f(std::integral_constant<size_t, I>{}...);
   41|  1.18k|}
_ZN8fuzztest8internal10ApplyIndexILm1EZNKS0_8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvEUlDpT_E_EEDaT0_:
   54|  1.20k|constexpr auto ApplyIndex(F f) {
   55|  1.20k|  return ApplyIndexImpl(f, std::make_index_sequence<N>{});
   56|  1.20k|}
_ZN8fuzztest8internal14ApplyIndexImplIJLm0EEZNKS0_8IRObject8ToCorpusINSt3__15tupleIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEENS4_8optionalIT_EEvEUlDpT_E_EEDaT0_NS4_16integer_sequenceImJXspT_EEEE:
   39|  1.20k|constexpr auto ApplyIndexImpl(F f, std::index_sequence<I...>) {
   40|  1.20k|  return f(std::integral_constant<size_t, I>{}...);
   41|  1.20k|}
_ZN8fuzztest8internal11CheckIsSameINSt3__15tupleIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEESA_EEvv:
  806|      4|constexpr void CheckIsSame() {
  807|      4|  static_assert(std::is_same_v<T, U>);
  808|      4|}
_ZN8fuzztest8internal11CheckIsSameINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES8_EEvv:
  806|      4|constexpr void CheckIsSame() {
  807|      4|  static_assert(std::is_same_v<T, U>);
  808|      4|}
_ZN8fuzztest8internal11CheckIsSameIccEEvv:
  806|      4|constexpr void CheckIsSame() {
  807|      4|  static_assert(std::is_same_v<T, U>);
  808|      4|}

_ZN8fuzztest15GetRegistrationIPFvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEEEDaNS1_12basic_stringIcS4_NS1_9allocatorIcEEEESB_SB_iT_:
  339|      2|                     TargetFunction target_function) {
  340|      2|  return ::fuzztest::internal::Registration<::fuzztest::internal::NoFixture,
  341|      2|                                            TargetFunction>(
  342|      2|      ::fuzztest::internal::BasicTestInfo{std::move(suite_name),
  343|      2|                                          std::move(test_name), std::move(file),
  344|      2|                                          line, false},
  345|      2|      target_function);
  346|      2|}
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_23DefaultRegistrationBaseIJS7_EEEPvEC2ENS0_13BasicTestInfoES9_:
  134|      2|      : test_info_(std::move(info)), target_function_(target_function) {}
_ZNO8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_23DefaultRegistrationBaseIJS7_EEEPvE11WithDomainsIJRNS0_23SequenceContainerOfImplINS3_12basic_stringIcS6_NS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEEEEDaDpOT_:
  172|      2|  auto WithDomains(NewDomains&&... domains) && {
  173|      2|    return std::move(*this).WithDomains(
  174|      2|        TupleOf(std::forward<NewDomains>(domains)...));
  175|      2|  }
_ZNO8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_23DefaultRegistrationBaseIJS7_EEEPvE11WithDomainsIJNS0_23SequenceContainerOfImplINS3_12basic_stringIcS6_NS3_9allocatorIcEEEENS0_13ArbitraryImplIcvEEEEEEEDaNS0_15AggregateOfImplINS3_5tupleIJDpNT_10value_typeEEEELNS0_23RequireCustomCorpusTypeE0EJDpSP_EEE:
  149|      2|                       domain) && {
  150|      2|    static_assert(!Registration::kHasDomain,
  151|      2|                  "WithDomains can only be called once.");
  152|      2|    static_assert(!Registration::kHasSeeds,
  153|      2|                  "WithDomains can not be called after WithSeeds.");
  154|      2|    static_assert(!Registration::kHasSeedProvider,
  155|      2|                  "WithDomains can not be called after WithSeedProvider.");
  156|      2|    static_assert(
  157|      2|        Base::kNumArgs == sizeof...(NewDomains),
  158|      2|        "Number of domains specified in .WithDomains() does not match "
  159|      2|        "the number of function parameters.");
  160|      2|    using NewBase = RegistrationWithDomainsBase<value_type_t<NewDomains>...>;
  161|      2|    return Registration<Fixture, TargetFunction, NewBase, SeedProvider>(
  162|      2|        std::move(test_info_), target_function_, NewBase{std::move(domain)});
  163|      2|  }
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvEC2ENS0_13BasicTestInfoES9_SF_:
  294|      2|      : Base(std::move(base)),
  295|      2|        test_info_(std::move(info)),
  296|      2|        target_function_(target_function) {}
_ZNK8fuzztest8internal27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEE10GetDomainsEv:
   95|      2|  const auto& GetDomains() const { return domains_; }
_ZNK8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvE5seedsEv:
  272|      2|  std::vector<GenericDomainCorpusType> seeds() const {
  273|       |    if constexpr (Base::kHasSeeds) {
  274|       |      return this->seeds_;
  275|      2|    } else {
  276|      2|      return {};
  277|      2|    }
  278|      2|  }
_ZN8fuzztest8internal12RegistrationINS0_9NoFixtureEPFvNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEENS0_27RegistrationWithDomainsBaseIJNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEEEEPvE13seed_providerEv:
  280|      2|  SeedProvider seed_provider() {
  281|       |    if constexpr (Base::kHasSeedProvider) {
  282|       |      return std::move(this->seed_provider_);
  283|      2|    } else {
  284|      2|      return {};
  285|      2|    }
  286|      2|  }

_ZN8fuzztest8internal11ForEachTestEN4absl12lts_2024011611FunctionRefIFvRNS0_8FuzzTestEEEE:
   56|      6|void ForEachTest(absl::FunctionRef<void(FuzzTest&)> func) {
   57|      6|  for (auto& t : Regs()) func(t);
  ------------------
  |  Branch (57:16): [True: 6, False: 6]
  ------------------
   58|      6|}
_ZN8fuzztest8internal12RegisterImplENS0_13BasicTestInfoEN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrINS0_14FuzzTestFuzzerENS5_14default_deleteIS7_EEEERKNS0_8FuzzTestEEEE:
   60|      2|void RegisterImpl(BasicTestInfo test_info, FuzzTestFuzzerFactory factory) {
   61|      2|  Regs().emplace_back(std::move(test_info), std::move(factory));
   62|      2|}
registry.cc:_ZN8fuzztest8internal12_GLOBAL__N_14RegsEv:
   30|      8|auto& Regs() {
   31|       |  // We use a deque because FuzzTest is not copyable/movable.
   32|      8|  static auto* reg = new std::deque<FuzzTest>;
   33|      8|  return *reg;
   34|      8|}

_ZN8fuzztest8internal17RegistrationTokenaSINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEENS0_9NoFixtureEPFvNS4_17basic_string_viewIcS7_EEEPvEERS1_ONS0_12RegistrationIT0_T1_T_T2_EE:
   57|      2|      Registration<Fixture, TargetFunction, RegBase, SeedProvider>&& reg) {
   58|       |    if constexpr (std::is_base_of_v<FixtureWithExplicitSetUp, Fixture>) {
   59|       |      RegisterSetUpTearDownTestSuiteFunctions(reg.test_info_.suite_name,
   60|       |                                              &Fixture::SetUpTestSuite,
   61|       |                                              &Fixture::TearDownTestSuite);
   62|       |    }
   63|      2|    BasicTestInfo test_info = reg.test_info_;
   64|      2|    RegisterImpl(std::move(test_info),
   65|      2|                 GetFuzzTestFuzzerFactory(std::move(reg)));
   66|      2|    return *this;
   67|      2|  }
_ZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEENS0_9NoFixtureEPFvNS4_17basic_string_viewIcS7_EEEPvEEN4absl12lts_2024011612AnyInvocableIKFNS4_10unique_ptrINS0_14FuzzTestFuzzerENS4_14default_deleteISM_EEEERKNS0_8FuzzTestEEEEONS0_12RegistrationIT0_T1_T_T2_EE:
   72|      2|      Registration<Fixture, TargetFunction, RegBase, SeedProvider>&& reg) {
   73|       |#if defined(FUZZTEST_COMPATIBILITY_MODE) && defined(FUZZTEST_USE_CENTIPEDE)
   74|       |#error FuzzTest compatibility mode cannot work together with Centipede.
   75|       |#endif
   76|      2|#if defined(FUZZTEST_COMPATIBILITY_MODE)
   77|      2|    using FuzzerImpl = FuzzTestExternalEngineAdaptor;
   78|       |#elif defined(FUZZTEST_USE_CENTIPEDE)
   79|       |    using FuzzerImpl = CentipedeFuzzerAdaptor;
   80|       |#else
   81|       |    using FuzzerImpl = FuzzTestFuzzerImpl;
   82|       |#endif
   83|       |
   84|      2|    return [target_function = reg.target_function_, domain = reg.GetDomains(),
   85|      2|            seeds = reg.seeds(), seed_provider = reg.seed_provider()](
   86|      2|               const FuzzTest& test) -> std::unique_ptr<FuzzTestFuzzer> {
   87|      2|      return std::make_unique<FuzzerImpl>(
   88|      2|          test,
   89|      2|          std::make_unique<FixtureDriverImpl<decltype(domain), Fixture,
   90|      2|                                             TargetFunction, SeedProvider>>(
   91|      2|              target_function, domain, seeds, seed_provider));
   92|      2|    };
   93|      2|  }
_ZZN8fuzztest8internal17RegistrationToken24GetFuzzTestFuzzerFactoryINS0_27RegistrationWithDomainsBaseIJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEENS0_9NoFixtureEPFvNS4_17basic_string_viewIcS7_EEEPvEEN4absl12lts_2024011612AnyInvocableIKFNS4_10unique_ptrINS0_14FuzzTestFuzzerENS4_14default_deleteISM_EEEERKNS0_8FuzzTestEEEEONS0_12RegistrationIT0_T1_T_T2_EEENKUlSS_E_clESS_:
   86|      2|               const FuzzTest& test) -> std::unique_ptr<FuzzTestFuzzer> {
   87|      2|      return std::make_unique<FuzzerImpl>(
   88|      2|          test,
   89|      2|          std::make_unique<FixtureDriverImpl<decltype(domain), Fixture,
   90|      2|                                             TargetFunction, SeedProvider>>(
   91|      2|              target_function, domain, seeds, seed_provider));
   92|      2|    };

_ZN8fuzztest8internal7Runtime19CheckWatchdogLimitsEv:
  258|  1.18k|void Runtime::CheckWatchdogLimits() {
  259|       |  // Centipede runner has its own watchdog.
  260|  1.18k|#ifndef FUZZTEST_USE_CENTIPEDE
  261|  1.18k|  if (current_configuration_ == nullptr) return;
  ------------------
  |  Branch (261:7): [True: 1.18k, False: 0]
  ------------------
  262|      0|  const absl::Duration run_duration =
  263|      0|      clock_fn_() - current_iteration_start_time_;
  264|      0|  if (current_configuration_->time_limit_per_input > absl::ZeroDuration() &&
  ------------------
  |  Branch (264:7): [True: 0, False: 0]
  ------------------
  265|      0|      run_duration > current_configuration_->time_limit_per_input) {
  ------------------
  |  Branch (265:7): [True: 0, False: 0]
  ------------------
  266|      0|    absl::FPrintF(
  267|      0|        GetStderr(), "[!] Per-input timeout exceeded: %s > %s - aborting\n",
  268|      0|        absl::FormatDuration(run_duration),
  269|      0|        absl::FormatDuration(current_configuration_->time_limit_per_input));
  270|      0|    std::abort();
  271|      0|  }
  272|      0|  const size_t rss_usage = GetPeakRSSBytes();
  273|      0|  if (current_configuration_->rss_limit > 0 &&
  ------------------
  |  Branch (273:7): [True: 0, False: 0]
  ------------------
  274|      0|      rss_usage > current_configuration_->rss_limit) {
  ------------------
  |  Branch (274:7): [True: 0, False: 0]
  ------------------
  275|      0|    absl::FPrintF(GetStderr(),
  276|      0|                  "[!] RSS limit exceeded: %zu > %zu (bytes) - aborting\n",
  277|      0|                  rss_usage, current_configuration_->rss_limit);
  278|      0|    std::abort();
  279|      0|  }
  280|      0|#endif
  281|      0|}
_ZN8fuzztest8internal7Runtime18OnTestIterationEndEv:
  283|  1.18k|void Runtime::OnTestIterationEnd() {
  284|  1.18k|  test_iteration_started_ = false;
  285|  1.18k|  while (watchdog_spinlock_.test_and_set()) std::this_thread::yield();
  ------------------
  |  Branch (285:10): [True: 0, False: 1.18k]
  ------------------
  286|  1.18k|  CheckWatchdogLimits();
  287|  1.18k|  watchdog_spinlock_.clear();
  288|  1.18k|}
_ZN8fuzztest8internal21InstallSignalHandlersEP8_IO_FILE:
  397|      2|void InstallSignalHandlers(FILE* out) {
  398|      2|  if (signal_out != nullptr) {
  ------------------
  |  Branch (398:7): [True: 0, False: 2]
  ------------------
  399|       |    // Already installed. Noop.
  400|      0|    return;
  401|      0|  }
  402|      2|  signal_out = out;
  403|       |
  404|       |#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER)
  405|       |  // An ASan failure might come without a signal.
  406|       |  // Eg a divide by zero is intercepted by ASan and it terminates the process
  407|       |  // after printing its output. This handler helps us print our output
  408|       |  // afterwards.
  409|       |  __sanitizer_set_death_callback(
  410|       |      [](auto...) { Runtime::instance().PrintReport(&signal_out_sink); });
  411|       |#endif
  412|       |
  413|     12|  for (OldSignalHandler& h : crash_handlers) {
  ------------------
  |  Branch (413:28): [True: 12, False: 2]
  ------------------
  414|     12|    SetNewSigAction(h.signum, &HandleCrash, &h.action);
  415|     12|  }
  416|       |
  417|      6|  for (OldSignalHandler& h : termination_handlers) {
  ------------------
  |  Branch (417:28): [True: 6, False: 2]
  ------------------
  418|      6|    SetNewSigAction(h.signum, &HandleTermination, nullptr);
  419|      6|  }
  420|      2|}
_ZN8fuzztest8internal18FuzzTestFuzzerImplC2ERKNS0_8FuzzTestENSt3__110unique_ptrINS0_20UntypedFixtureDriverENS5_14default_deleteIS7_EEEE:
  443|      2|    : test_(test),
  444|      2|      fixture_driver_(std::move(fixture_driver)),
  445|      2|      params_domain_(fixture_driver_->GetDomains()),
  446|      2|      execution_coverage_(internal::GetExecutionCoverage()),
  447|      2|      corpus_coverage_(execution_coverage_ != nullptr
  ------------------
  |  Branch (447:24): [True: 0, False: 2]
  ------------------
  448|      2|                           ? execution_coverage_->GetCounterMap().size()
  449|      2|                           : 0) {
  450|      2|  FUZZTEST_INTERNAL_CHECK_PRECONDITION(fixture_driver_ != nullptr,
  ------------------
  |  |   42|      2|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 2, False: 0]
  |  |  ------------------
  |  |   43|      2|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
  451|      2|                                       "Invalid fixture driver!");
  452|      2|  stats_.start_time = absl::Now();
  453|      2|  const char* corpus_out_dir_chars = getenv("FUZZTEST_TESTSUITE_OUT_DIR");
  454|      2|  if (corpus_out_dir_chars) corpus_out_dir_ = corpus_out_dir_chars;
  ------------------
  |  Branch (454:7): [True: 0, False: 2]
  ------------------
  455|       |
  456|      2|  std::vector<double> weights = {100.};
  457|      2|  corpus_distribution_ =
  458|      2|      absl::discrete_distribution<>(weights.begin(), weights.end());
  459|      2|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl8TryParseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  466|  4.91k|    absl::string_view data) {
  467|  4.91k|  auto ir_value = IRObject::FromString(data);
  468|  4.91k|  if (!ir_value) {
  ------------------
  |  Branch (468:7): [True: 1.58k, False: 3.32k]
  ------------------
  469|  1.58k|    absl::FPrintF(GetStderr(), "[!] Unexpected file format.\n");
  470|  1.58k|    return std::nullopt;
  471|  1.58k|  }
  472|  3.32k|  auto corpus_value = params_domain_.ParseCorpus(*ir_value);
  473|  3.32k|  if (!corpus_value) {
  ------------------
  |  Branch (473:7): [True: 2.14k, False: 1.18k]
  ------------------
  474|  2.14k|    absl::FPrintF(GetStderr(), "[!] Unexpected intermediate representation.\n");
  475|  2.14k|    return std::nullopt;
  476|  2.14k|  }
  477|       |
  478|  1.18k|  absl::Status is_valid = params_domain_.ValidateCorpusValue(*corpus_value);
  479|  1.18k|  if (!is_valid.ok()) {
  ------------------
  |  Branch (479:7): [True: 0, False: 1.18k]
  ------------------
  480|      0|    absl::FPrintF(GetStderr(), "[!] Invalid corpus value: %s\n",
  481|      0|                  is_valid.ToString());
  482|      0|    return std::nullopt;
  483|      0|  }
  484|  1.18k|  return corpus_value;
  485|  1.18k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl10ShouldStopEv:
  775|  4.91k|bool FuzzTestFuzzerImpl::ShouldStop() {
  776|  4.91k|  if (runs_limit_.has_value() && stats_.runs >= *runs_limit_) return true;
  ------------------
  |  Branch (776:7): [True: 0, False: 4.91k]
  |  Branch (776:34): [True: 0, False: 0]
  ------------------
  777|  4.91k|  if (time_limit_ != absl::InfiniteFuture() && absl::Now() > time_limit_)
  ------------------
  |  Branch (777:7): [True: 0, False: 4.91k]
  |  Branch (777:48): [True: 0, False: 0]
  ------------------
  778|      0|    return true;
  779|  4.91k|  return runtime_.termination_requested();
  780|  4.91k|}
_ZN8fuzztest8internal18FuzzTestFuzzerImpl11RunOneInputERKNS1_5InputE:
  905|  1.18k|    const Input& input) {
  906|  1.18k|  ++stats_.runs;
  907|  1.18k|  auto untyped_args = params_domain_.GetValue(input.args);
  908|  1.18k|  Runtime::Args debug_args{input.args, params_domain_};
  909|  1.18k|  runtime_.SetCurrentArgs(&debug_args);
  910|       |
  911|       |  // Reset and observe the coverage map and start tracing in
  912|       |  // the tightest scope possible. In particular, we can't include the call
  913|       |  // to GetValue in the scope as it will run user code.
  914|  1.18k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (914:7): [True: 0, False: 1.18k]
  ------------------
  915|      0|    execution_coverage_->ResetState();
  916|      0|  }
  917|  1.18k|  absl::Time start = absl::Now();
  918|  1.18k|  runtime_.OnTestIterationStart(start);
  919|       |  // Set tracing after absl::Now(), otherwise it will make
  920|       |  // FuzzingModeTest.MinimizesDuplicatedCorpustest flaky because
  921|       |  // randomness in absl::Now() being traced by cmp coverage.
  922|  1.18k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (922:7): [True: 0, False: 1.18k]
  ------------------
  923|      0|    execution_coverage_->SetIsTracing(true);
  924|      0|  }
  925|       |
  926|  1.18k|  fixture_driver_->SetUpIteration();
  927|  1.18k|  fixture_driver_->Test(std::move(untyped_args));
  928|  1.18k|  fixture_driver_->TearDownIteration();
  929|  1.18k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (929:7): [True: 0, False: 1.18k]
  ------------------
  930|      0|    execution_coverage_->SetIsTracing(false);
  931|      0|  }
  932|  1.18k|  const absl::Duration run_time = absl::Now() - start;
  933|       |
  934|  1.18k|  bool new_coverage = false;
  935|  1.18k|  if (execution_coverage_ != nullptr) {
  ------------------
  |  Branch (935:7): [True: 0, False: 1.18k]
  ------------------
  936|      0|    new_coverage = corpus_coverage_.Update(execution_coverage_);
  937|      0|    stats_.max_stack_used =
  938|      0|        std::max(stats_.max_stack_used, execution_coverage_->MaxStackUsed());
  939|      0|  }
  940|       |
  941|  1.18k|  runtime_.OnTestIterationEnd();
  942|  1.18k|  runtime_.UnsetCurrentArgs();
  943|  1.18k|  return {new_coverage, run_time};
  944|  1.18k|}
runtime.cc:_ZN8fuzztest8internalL15SetNewSigActionEiPFviP9siginfo_tPvEP9sigaction:
  380|     18|                            struct sigaction* old_sigact) {
  381|     18|  struct sigaction new_sigact = {};
  382|     18|  sigemptyset(&new_sigact.sa_mask);
  383|     18|  new_sigact.sa_sigaction = handler;
  384|       |
  385|       |  // We make use of the SA_ONSTACK flag so that signal handlers are executed on
  386|       |  // a separate stack. This is needed to properly handle cases where stack space
  387|       |  // is limited and the delivery of a signal needs to be properly handled.
  388|     18|  new_sigact.sa_flags = SA_SIGINFO | SA_ONSTACK;
  389|       |
  390|     18|  if (sigaction(signum, &new_sigact, old_sigact) == -1) {
  ------------------
  |  Branch (390:7): [True: 0, False: 18]
  ------------------
  391|      0|    fprintf(GetStderr(), "Error installing signal handler: %s\n",
  392|       |            strerror(errno));
  393|      0|    exit(1);
  394|      0|  }
  395|     18|}

_ZN8fuzztest8internal8FuzzTestC2ENS0_13BasicTestInfoEN4absl12lts_2024011612AnyInvocableIKFNSt3__110unique_ptrINS0_14FuzzTestFuzzerENS6_14default_deleteIS8_EEEERKS1_EEE:
   83|      2|      : test_info_(std::move(test_info)), make_(std::move(factory)) {}
_ZNK8fuzztest8internal8FuzzTest10suite_nameEv:
   85|      2|  const std::string& suite_name() const { return test_info_.suite_name; }
_ZNK8fuzztest8internal8FuzzTest9test_nameEv:
   86|      2|  const std::string& test_name() const { return test_info_.test_name; }
_ZNK8fuzztest8internal8FuzzTest9full_nameEv:
   87|      6|  std::string full_name() const {
   88|      6|    return absl::StrCat(test_info_.suite_name, ".", test_info_.test_name);
   89|      6|  }
_ZNK8fuzztest8internal8FuzzTest4fileEv:
   90|      2|  const std::string& file() const { return test_info_.file; }
_ZNK8fuzztest8internal8FuzzTest4lineEv:
   91|      2|  int line() const { return test_info_.line; }
_ZNK8fuzztest8internal8FuzzTest12uses_fixtureEv:
   92|      2|  bool uses_fixture() const { return test_info_.uses_fixture; }
_ZNK8fuzztest8internal8FuzzTest4makeEv:
   93|      2|  auto make() const { return make_(*this); }
_ZN8fuzztest8internal7Runtime8instanceEv:
  117|      8|  static Runtime& instance() {
  118|      8|    static auto* runtime = new Runtime();
  119|      8|    return *runtime;
  120|      8|  }
_ZNK8fuzztest8internal7Runtime21termination_requestedEv:
  141|  4.91k|  bool termination_requested() const {
  142|  4.91k|    return termination_requested_.load(std::memory_order_relaxed);
  143|  4.91k|  }
_ZN8fuzztest8internal7Runtime10SetRunModeENS_7RunModeE:
  147|      4|  void SetRunMode(RunMode run_mode) { run_mode_ = run_mode; }
_ZNK8fuzztest8internal7Runtime8run_modeEv:
  148|      2|  RunMode run_mode() const { return run_mode_; }
_ZN8fuzztest8internal7Runtime14EnableReporterEPKNS0_12RuntimeStatsEPFN4absl12lts_202401164TimeEvE:
  150|      2|  void EnableReporter(const RuntimeStats* stats, absl::Time (*clock_fn)()) {
  151|      2|    reporter_enabled_ = true;
  152|      2|    stats_ = stats;
  153|      2|    clock_fn_ = clock_fn;
  154|       |    // In case we have not installed them yet, do so now.
  155|      2|    InstallSignalHandlers(GetStderr());
  156|      2|  }
_ZN8fuzztest8internal7Runtime14SetCurrentTestEPKNS0_8FuzzTestEPKNS0_13ConfigurationE:
  165|  4.91k|                      const Configuration* configuration) {
  166|  4.91k|    current_test_ = test;
  167|  4.91k|    current_configuration_ = configuration;
  168|  4.91k|  }
_ZN8fuzztest8internal7Runtime20OnTestIterationStartERKN4absl12lts_202401164TimeE:
  169|  1.18k|  void OnTestIterationStart(const absl::Time& start_time) {
  170|  1.18k|    current_iteration_start_time_ = start_time;
  171|  1.18k|    test_iteration_started_ = true;
  172|  1.18k|  }
_ZN8fuzztest8internal7Runtime14SetCurrentArgsEPNS1_4ArgsE:
  175|  1.18k|  void SetCurrentArgs(Args* args) { current_args_ = args; }
_ZN8fuzztest8internal7Runtime16UnsetCurrentArgsEv:
  176|  1.18k|  void UnsetCurrentArgs() { current_args_ = nullptr; }
_ZN8fuzztest8internal7RuntimeC2Ev:
  184|      2|  Runtime() = default;

_ZN8fuzztest8internal23GetFromEnvOrMakeSeedSeqERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS1_17basic_string_viewIcS4_EE:
   63|      2|                                      absl::string_view env_var) {
   64|      2|  const std::vector<uint32_t> seed_material =
   65|      2|      GetFromEnvOrMakeSeedMaterial(env_var);
   66|      2|  const std::string encoded_seed_material = EncodeSeedMaterial(seed_material);
   67|      2|  out << env_var << "=" << encoded_seed_material << '\n';
   68|      2|  return std::seed_seq(seed_material.begin(), seed_material.end());
   69|      2|}
_ZN8fuzztest8internal18EncodeSeedMaterialEN4absl12lts_202401164SpanIKjEE:
   71|      2|std::string EncodeSeedMaterial(absl::Span<const uint32_t> seed_material) {
   72|      2|  return absl::WebSafeBase64Escape(
   73|      2|      absl::string_view(reinterpret_cast<const char*>(seed_material.data()),
   74|      2|                        seed_material.size() * sizeof(uint32_t)));
   75|      2|}
seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_128GetFromEnvOrMakeSeedMaterialENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   47|      2|std::vector<uint32_t> GetFromEnvOrMakeSeedMaterial(absl::string_view env_var) {
   48|      2|  const char* encoded_seed_material = std::getenv(env_var.data());
   49|      2|  if (encoded_seed_material == nullptr) {
  ------------------
  |  Branch (49:7): [True: 2, False: 0]
  ------------------
   50|      2|    return MakeSeedMaterial();
   51|      2|  }
   52|      0|  std::optional<std::vector<uint32_t>> seed_material =
   53|      0|      DecodeSeedMaterial(encoded_seed_material);
   54|      0|  FUZZTEST_INTERNAL_CHECK_PRECONDITION(
  ------------------
  |  |   42|      0|  ((P) ? (void)0                                     \
  |  |  ------------------
  |  |  |  Branch (42:4): [True: 0, False: 0]
  |  |  ------------------
  |  |   43|      0|       : ::fuzztest::internal::Abort(                \
  |  |   44|      0|             __FILE__, __LINE__,                     \
  |  |   45|      0|             absl::StrCat("Failed precondition (", #P, "): ", __VA_ARGS__)))
  ------------------
   55|      0|      seed_material.has_value(),
   56|      0|      "Failed to decode seed material from the environment variable ", env_var);
   57|      0|  return *std::move(seed_material);
   58|      2|}
seed_seq.cc:_ZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEv:
   37|      2|std::vector<uint32_t> MakeSeedMaterial() {
   38|      2|  absl::BitGen gen;
   39|      2|  static constexpr int kNumberOfEntropyBits = 256;
   40|      2|  std::vector<uint32_t> seed_material(kNumberOfEntropyBits /
   41|      2|                                      (8 * sizeof(uint32_t)));
   42|      2|  std::generate(seed_material.begin(), seed_material.end(),
   43|      2|                [&gen] { return absl::Uniform<uint32_t>(gen); });
   44|      2|  return seed_material;
   45|      2|}
seed_seq.cc:_ZZN8fuzztest8internal12_GLOBAL__N_116MakeSeedMaterialEvENK3$_0clEv:
   43|     16|                [&gen] { return absl::Uniform<uint32_t>(gen); });

_ZN8fuzztest8internal8IRObject10FromStringENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  331|  4.91k|std::optional<IRObject> IRObject::FromString(absl::string_view str) {
  332|  4.91k|  IRObject object;
  333|  4.91k|  if (IsInBinaryFormat(str)) {
  ------------------
  |  Branch (333:7): [True: 1.14k, False: 3.76k]
  ------------------
  334|  1.14k|    BinaryParseBuf buf = {str.data(), str.size()};
  335|  1.14k|    buf.Advance(kBinaryHeader.size());
  336|  1.14k|    if (!BinaryParse(object, buf, /*recursion_depth=*/0) || !buf.empty())
  ------------------
  |  Branch (336:9): [True: 41, False: 1.10k]
  |  Branch (336:61): [True: 1, False: 1.10k]
  ------------------
  337|     42|      return std::nullopt;
  338|  3.76k|  } else {
  339|  3.76k|    if (ReadToken(str) != kHeader) return std::nullopt;
  ------------------
  |  Branch (339:9): [True: 84, False: 3.68k]
  ------------------
  340|  3.68k|    if (!ParseImpl(object, str, /*recursion_depth=*/0) ||
  ------------------
  |  Branch (340:9): [True: 1.36k, False: 2.32k]
  |  Branch (340:9): [True: 1.46k, False: 2.22k]
  ------------------
  341|  2.32k|        !ReadToken(str).empty())
  ------------------
  |  Branch (341:9): [True: 101, False: 2.22k]
  ------------------
  342|  1.46k|      return std::nullopt;
  343|  3.68k|  }
  344|  3.32k|  return object;
  345|  4.91k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_116IsInBinaryFormatENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  302|  4.91k|bool IsInBinaryFormat(absl::string_view str) {
  303|       |  // Not using absl::string_view or std::memcmp because they could be
  304|       |  // instrumented and using them could pollute coverage.
  305|  4.91k|  return str.size() >= kBinaryHeader.size() &&
  ------------------
  |  Branch (305:10): [True: 4.84k, False: 66]
  ------------------
  306|  4.84k|         __builtin_memcmp(str.data(), kBinaryHeader.data(),
  ------------------
  |  Branch (306:10): [True: 1.14k, False: 3.70k]
  ------------------
  307|  4.84k|                          kBinaryHeader.size()) == 0;
  308|  4.91k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf7AdvanceEm:
  242|  11.3k|  inline void Advance(size_t s) {
  243|  11.3k|    if (s > size) s = size;
  ------------------
  |  Branch (243:9): [True: 0, False: 11.3k]
  ------------------
  244|  11.3k|    str += s;
  245|  11.3k|    size -= s;
  246|  11.3k|  }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_111BinaryParseERNS0_8IRObjectERNS1_14BinaryParseBufEi:
  249|  5.81k|bool BinaryParse(IRObject& obj, BinaryParseBuf& buf, int recursion_depth) {
  250|  5.81k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (250:7): [True: 0, False: 5.81k]
  ------------------
  251|  5.81k|  if (buf.empty()) return false;
  ------------------
  |  Branch (251:7): [True: 5, False: 5.81k]
  ------------------
  252|  5.81k|  const auto h = static_cast<BinaryFormatHeader>(buf.str[0]);
  253|  5.81k|  buf.Advance(1);
  254|  5.81k|  switch (h) {
  ------------------
  |  Branch (254:11): [True: 5.78k, False: 28]
  ------------------
  255|  2.53k|    case BinaryFormatHeader::kEmpty: {
  ------------------
  |  Branch (255:5): [True: 2.53k, False: 3.27k]
  ------------------
  256|  2.53k|      return true;
  257|      0|    }
  258|    464|    case BinaryFormatHeader::kUInt64: {
  ------------------
  |  Branch (258:5): [True: 464, False: 5.34k]
  ------------------
  259|    464|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (259:11): [True: 0, False: 464]
  ------------------
  260|    464|      auto& t = obj.value.emplace<uint64_t>();
  261|    464|      std::memcpy(&t, buf.str, sizeof(uint64_t));
  262|    464|      buf.Advance(sizeof(uint64_t));
  263|    464|      return true;
  264|    464|    }
  265|      2|    case BinaryFormatHeader::kDouble: {
  ------------------
  |  Branch (265:5): [True: 2, False: 5.80k]
  ------------------
  266|      2|      if (buf.size < sizeof(double)) return false;
  ------------------
  |  Branch (266:11): [True: 2, False: 0]
  ------------------
  267|      0|      auto& t = obj.value.emplace<double>();
  268|      0|      std::memcpy(&t, buf.str, sizeof(t));
  269|      0|      buf.Advance(sizeof(double));
  270|      0|      return true;
  271|      2|    }
  272|  1.10k|    case BinaryFormatHeader::kString: {
  ------------------
  |  Branch (272:5): [True: 1.10k, False: 4.70k]
  ------------------
  273|  1.10k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (273:11): [True: 2, False: 1.10k]
  ------------------
  274|  1.10k|      uint64_t str_size;
  275|  1.10k|      std::memcpy(&str_size, buf.str, sizeof(str_size));
  276|  1.10k|      buf.Advance(sizeof(uint64_t));
  277|  1.10k|      if (buf.size < str_size) return false;
  ------------------
  |  Branch (277:11): [True: 2, False: 1.10k]
  ------------------
  278|  1.10k|      obj.value.emplace<std::string>() = {buf.str,
  279|  1.10k|                                          static_cast<size_t>(str_size)};
  280|  1.10k|      buf.Advance(str_size);
  281|  1.10k|      return true;
  282|  1.10k|    }
  283|  1.67k|    case BinaryFormatHeader::kObject: {
  ------------------
  |  Branch (283:5): [True: 1.67k, False: 4.13k]
  ------------------
  284|  1.67k|      if (buf.size < sizeof(uint64_t)) return false;
  ------------------
  |  Branch (284:11): [True: 1, False: 1.67k]
  ------------------
  285|  1.67k|      uint64_t vec_size;
  286|  1.67k|      std::memcpy(&vec_size, buf.str, sizeof(vec_size));
  287|  1.67k|      buf.Advance(sizeof(vec_size));
  288|       |      // This could happen for malformed inputs.
  289|  1.67k|      if (vec_size > buf.size) return false;
  ------------------
  |  Branch (289:11): [True: 1, False: 1.67k]
  ------------------
  290|  1.67k|      auto& v = obj.value.emplace<std::vector<IRObject>>();
  291|  1.67k|      v.reserve(vec_size);
  292|  6.04k|      for (uint64_t i = 0; i < vec_size; ++i) {
  ------------------
  |  Branch (292:28): [True: 4.67k, False: 1.37k]
  ------------------
  293|  4.67k|        if (!BinaryParse(v.emplace_back(), buf, recursion_depth + 1))
  ------------------
  |  Branch (293:13): [True: 292, False: 4.37k]
  ------------------
  294|    292|          return false;
  295|  4.67k|      }
  296|  1.37k|      return true;
  297|  1.67k|    }
  298|  5.81k|  }
  299|     28|  return false;
  300|  5.81k|}
serialization.cc:_ZNK8fuzztest8internal12_GLOBAL__N_114BinaryParseBuf5emptyEv:
  241|  6.92k|  inline bool empty() const { return size == 0; }
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   78|   227k|absl::string_view ReadToken(absl::string_view& in) {
   79|   249k|  while (!in.empty() && std::isspace(in[0])) in.remove_prefix(1);
  ------------------
  |  Branch (79:10): [True: 246k, False: 3.15k]
  |  Branch (79:25): [True: 21.9k, False: 224k]
  ------------------
   80|   227k|  if (in.empty()) return in;
  ------------------
  |  Branch (80:7): [True: 3.15k, False: 224k]
  ------------------
   81|   224k|  size_t end = 1;
   82|   224k|  const auto is_literal = [](char c) {
   83|   224k|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
   84|   224k|  };
   85|   224k|  if (is_literal(in[0])) {
  ------------------
  |  Branch (85:7): [True: 114k, False: 110k]
  ------------------
   86|  56.2M|    while (end < in.size() && is_literal(in[end])) ++end;
  ------------------
  |  Branch (86:12): [True: 56.2M, False: 3.12k]
  |  Branch (86:31): [True: 56.1M, False: 111k]
  ------------------
   87|   114k|  } else if (in[0] == '"') {
  ------------------
  |  Branch (87:14): [True: 502, False: 109k]
  ------------------
   88|  7.56M|    while (end < in.size() && in[end] != '"') ++end;
  ------------------
  |  Branch (88:12): [True: 7.56M, False: 51]
  |  Branch (88:31): [True: 7.56M, False: 451]
  ------------------
   89|    502|    if (end < in.size()) ++end;
  ------------------
  |  Branch (89:9): [True: 451, False: 51]
  ------------------
   90|    502|  }
   91|   224k|  absl::string_view res = in.substr(0, end);
   92|   224k|  in.remove_prefix(end);
   93|   224k|  return res;
   94|   227k|}
serialization.cc:_ZZN8fuzztest8internal12_GLOBAL__N_19ReadTokenERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEENK3$_0clEc:
   82|  56.4M|  const auto is_literal = [](char c) {
   83|  56.4M|    return std::isalnum(c) != 0 || c == '+' || c == '-' || c == '.';
  ------------------
  |  Branch (83:12): [True: 56.0M, False: 364k]
  |  Branch (83:36): [True: 1.78k, False: 362k]
  |  Branch (83:48): [True: 128k, False: 234k]
  |  Branch (83:60): [True: 12.8k, False: 221k]
  ------------------
   84|  56.4M|  };
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_19ParseImplERNS0_8IRObjectERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEi:
  136|  40.9k|bool ParseImpl(IRObject& obj, absl::string_view& str, int recursion_depth) {
  137|  40.9k|  if (recursion_depth > kMaxParseRecursionDepth) return false;
  ------------------
  |  Branch (137:7): [True: 0, False: 40.9k]
  ------------------
  138|  40.9k|  absl::string_view key = ReadToken(str);
  139|  40.9k|  if (key.empty() || key == "}") {
  ------------------
  |  Branch (139:7): [True: 47, False: 40.9k]
  |  Branch (139:22): [True: 587, False: 40.3k]
  ------------------
  140|       |    // The object is empty. Put the token back and return.
  141|    634|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  142|    634|    return true;
  143|    634|  }
  144|       |
  145|  40.3k|  if (key == "sub") {
  ------------------
  |  Branch (145:7): [True: 3.28k, False: 37.0k]
  ------------------
  146|  3.28k|    auto& v = obj.value.emplace<std::vector<IRObject>>();
  147|  37.3k|    do {
  148|  37.3k|      if (ReadToken(str) != "{") return false;
  ------------------
  |  Branch (148:11): [True: 37, False: 37.2k]
  ------------------
  149|  37.2k|      if (!ParseImpl(v.emplace_back(), str, recursion_depth + 1)) return false;
  ------------------
  |  Branch (149:11): [True: 2.14k, False: 35.1k]
  ------------------
  150|  35.1k|      if (ReadToken(str) != "}") return false;
  ------------------
  |  Branch (150:11): [True: 666, False: 34.4k]
  ------------------
  151|  34.4k|      key = ReadToken(str);
  152|  34.4k|    } while (key == "sub");
  ------------------
  |  Branch (152:14): [True: 34.0k, False: 433]
  ------------------
  153|       |    // We are done reading this repeated sub.
  154|       |    // Put the token back for the caller.
  155|    433|    str = absl::string_view(key.data(), str.data() + str.size() - key.data());
  156|    433|    return true;
  157|  37.0k|  } else {
  158|  37.0k|    if (ReadToken(str) != ":") return false;
  ------------------
  |  Branch (158:9): [True: 17, False: 37.0k]
  ------------------
  159|  37.0k|    auto value = ReadToken(str);
  160|  37.0k|    auto& v = obj.value;
  161|  37.0k|    if (key == "i") {
  ------------------
  |  Branch (161:9): [True: 11.9k, False: 25.0k]
  ------------------
  162|  11.9k|      return ReadScalar(v.emplace<uint64_t>(), value);
  163|  25.0k|    } else if (key == "d") {
  ------------------
  |  Branch (163:16): [True: 24.5k, False: 460]
  ------------------
  164|  24.5k|      return ReadScalar(v.emplace<double>(), value);
  165|  24.5k|    } else if (key == "s") {
  ------------------
  |  Branch (165:16): [True: 460, False: 0]
  ------------------
  166|    460|      return ReadScalar(v.emplace<std::string>(), value);
  167|    460|    } else {
  168|       |      // Unrecognized key
  169|      0|      return false;
  170|      0|    }
  171|  37.0k|  }
  172|  40.3k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERmNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   96|  11.9k|bool ReadScalar(uint64_t& out, absl::string_view value) {
   97|  11.9k|  return absl::SimpleAtoi(value, &out);
   98|  11.9k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERdNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  100|  24.5k|bool ReadScalar(double& out, absl::string_view value) {
  101|  24.5k|  return absl::SimpleAtod(value, &out);
  102|  24.5k|}
serialization.cc:_ZN8fuzztest8internal12_GLOBAL__N_110ReadScalarERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
  104|    460|bool ReadScalar(std::string& out, absl::string_view value) {
  105|    460|  if (value.empty() || value[0] != '"') return false;
  ------------------
  |  Branch (105:7): [True: 6, False: 454]
  |  Branch (105:24): [True: 0, False: 454]
  ------------------
  106|    454|  value.remove_prefix(1);
  107|       |
  108|    454|  if (value.empty() || value.back() != '"') return false;
  ------------------
  |  Branch (108:7): [True: 2, False: 452]
  |  Branch (108:24): [True: 1, False: 451]
  ------------------
  109|    451|  value.remove_suffix(1);
  110|       |
  111|  2.98M|  while (!value.empty()) {
  ------------------
  |  Branch (111:10): [True: 2.98M, False: 451]
  ------------------
  112|  2.98M|    if (value[0] != '\\') {
  ------------------
  |  Branch (112:9): [True: 2.98M, False: 0]
  ------------------
  113|  2.98M|      out += value[0];
  114|  2.98M|      value.remove_prefix(1);
  115|  2.98M|    } else {
  116|      0|      uint32_t v = 0;
  117|       |
  118|      0|      if (value.size() < 4) return false;
  ------------------
  |  Branch (118:11): [True: 0, False: 0]
  ------------------
  119|      0|      for (int i = 1; i < 4; ++i) {
  ------------------
  |  Branch (119:23): [True: 0, False: 0]
  ------------------
  120|      0|        if (value[i] < '0' || value[i] > '7') {
  ------------------
  |  Branch (120:13): [True: 0, False: 0]
  |  Branch (120:31): [True: 0, False: 0]
  ------------------
  121|      0|          return false;
  122|      0|        }
  123|      0|        v = 8 * v + value[i] - '0';
  124|      0|      }
  125|      0|      if (v > 255) return false;
  ------------------
  |  Branch (125:11): [True: 0, False: 0]
  ------------------
  126|       |
  127|      0|      out += static_cast<char>(v);
  128|      0|      value.remove_prefix(4);
  129|      0|    }
  130|  2.98M|  }
  131|    451|  return true;
  132|    451|}

_ZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEv:
  219|  3.32k|  std::optional<T> ToCorpus() const {
  220|       |    if constexpr (std::is_const_v<T>) {
  221|       |      return ToCorpus<std::remove_const_t<T>>();
  222|       |    } else if constexpr (is_monostate_v<T>) {
  223|       |      if (std::holds_alternative<std::monostate>(value)) return T{};
  224|       |      return std::nullopt;
  225|       |    } else if constexpr (std::is_same_v<T, IRObject>) {
  226|       |      return *this;
  227|       |    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  228|       |      if (auto v = GetScalar<T>()) {
  229|       |        return static_cast<T>(*v);
  230|       |      }
  231|       |      return std::nullopt;
  232|       |    } else if constexpr (is_variant_v<T>) {
  233|       |      auto elems = Subs();
  234|       |      if (!elems || elems->size() != 2) return std::nullopt;
  235|       |      auto index = (*elems)[0].ToCorpus<size_t>();
  236|       |      if (!index || *index >= std::variant_size_v<T>) return std::nullopt;
  237|       |      return Switch<std::variant_size_v<T>>(
  238|       |          *index, [&](auto I) -> std::optional<T> {
  239|       |            auto inner =
  240|       |                (*elems)[1].ToCorpus<std::variant_alternative_t<I, T>>();
  241|       |            if (inner) return T(std::in_place_index<I>, *std::move(inner));
  242|       |            return std::nullopt;
  243|       |          });
  244|       |    } else if constexpr (std::is_same_v<T, absl::int128> ||
  245|       |                         std::is_same_v<T, absl::uint128>) {
  246|       |      if (auto res = ToCorpus<std::pair<uint64_t, uint64_t>>()) {
  247|       |        return static_cast<T>(absl::MakeUint128(res->first, res->second));
  248|       |      }
  249|       |      return std::nullopt;
  250|       |    } else if constexpr (is_protocol_buffer_v<T>) {
  251|       |      const std::string* v = std::get_if<std::string>(&value);
  252|       |      T out;
  253|       |      if (v && out.ParseFromString(*v)) return out;
  254|       |      return std::nullopt;
  255|       |    } else if constexpr (is_dynamic_container_v<T>) {
  256|       |      if constexpr (is_bytevector_v<T>) {
  257|       |        const std::string* v = std::get_if<std::string>(&value);
  258|       |        if (v) {
  259|       |          T out;
  260|       |          out.resize(v->size());
  261|       |          std::memcpy(out.data(), v->data(), v->size());
  262|       |          return out;
  263|       |        }
  264|       |      }
  265|       |
  266|       |      auto elems = Subs();
  267|       |      if (!elems) return std::nullopt;
  268|       |
  269|       |      T out;
  270|       |      for (const auto& elem : *elems) {
  271|       |        if (auto inner = elem.ToCorpus<typename T::value_type>()) {
  272|       |          out.insert(out.end(), *std::move(inner));
  273|       |        } else {
  274|       |          return std::nullopt;
  275|       |        }
  276|       |      }
  277|       |      return out;
  278|  3.32k|    } else {
  279|       |      // Must be a tuple like object.
  280|  3.32k|      auto elems = Subs();
  281|  3.32k|      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  ------------------
  |  Branch (281:11): [True: 2.00k, False: 1.31k]
  |  Branch (281:21): [True: 113, False: 1.20k]
  ------------------
  282|  1.20k|      auto it = elems->begin();
  283|  1.20k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|  1.20k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|  1.20k|      });
  286|  1.20k|      return std::apply(
  287|  1.20k|          [&](auto&... part) -> std::optional<T> {
  288|  1.20k|            if ((!part || ...)) return std::nullopt;
  289|  1.20k|            return T{*std::move(part)...};
  290|  1.20k|          },
  291|  1.20k|          parts);
  292|  3.32k|    }
  293|  3.32k|  }
_ZNK8fuzztest8internal8IRObject4SubsEv:
  130|  3.32k|  std::optional<absl::Span<const IRObject>> Subs() const {
  131|  3.32k|    if (const auto* i = std::get_if<std::vector<IRObject>>(&value)) {
  ------------------
  |  Branch (131:21): [True: 1.31k, False: 2.01k]
  ------------------
  132|  1.31k|      return *i;
  133|  1.31k|    }
  134|       |    // The empty vector is serialized the same way as the monostate: nothing.
  135|       |    // Handle that case too.
  136|  2.01k|    if (std::holds_alternative<std::monostate>(value)) {
  ------------------
  |  Branch (136:9): [True: 3, False: 2.00k]
  ------------------
  137|      3|      return absl::Span<const IRObject>{};
  138|      3|    }
  139|  2.00k|    return std::nullopt;
  140|  2.01k|  }
_ZZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEvENKUlDpT_E_clIJNS3_17integral_constantImLm0EEEEEEDaSG_:
  283|  1.20k|      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|  1.20k|        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|  1.20k|      });
_ZNK8fuzztest8internal8IRObject8ToCorpusINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEENS3_8optionalIT_EEv:
  219|  1.20k|  std::optional<T> ToCorpus() const {
  220|       |    if constexpr (std::is_const_v<T>) {
  221|       |      return ToCorpus<std::remove_const_t<T>>();
  222|       |    } else if constexpr (is_monostate_v<T>) {
  223|       |      if (std::holds_alternative<std::monostate>(value)) return T{};
  224|       |      return std::nullopt;
  225|       |    } else if constexpr (std::is_same_v<T, IRObject>) {
  226|       |      return *this;
  227|  1.20k|    } else if constexpr (std::is_constructible_v<IRObject, T>) {
  228|  1.20k|      if (auto v = GetScalar<T>()) {
  ------------------
  |  Branch (228:16): [True: 1.18k, False: 21]
  ------------------
  229|  1.18k|        return static_cast<T>(*v);
  230|  1.18k|      }
  231|     21|      return std::nullopt;
  232|       |    } else if constexpr (is_variant_v<T>) {
  233|       |      auto elems = Subs();
  234|       |      if (!elems || elems->size() != 2) return std::nullopt;
  235|       |      auto index = (*elems)[0].ToCorpus<size_t>();
  236|       |      if (!index || *index >= std::variant_size_v<T>) return std::nullopt;
  237|       |      return Switch<std::variant_size_v<T>>(
  238|       |          *index, [&](auto I) -> std::optional<T> {
  239|       |            auto inner =
  240|       |                (*elems)[1].ToCorpus<std::variant_alternative_t<I, T>>();
  241|       |            if (inner) return T(std::in_place_index<I>, *std::move(inner));
  242|       |            return std::nullopt;
  243|       |          });
  244|       |    } else if constexpr (std::is_same_v<T, absl::int128> ||
  245|       |                         std::is_same_v<T, absl::uint128>) {
  246|       |      if (auto res = ToCorpus<std::pair<uint64_t, uint64_t>>()) {
  247|       |        return static_cast<T>(absl::MakeUint128(res->first, res->second));
  248|       |      }
  249|       |      return std::nullopt;
  250|       |    } else if constexpr (is_protocol_buffer_v<T>) {
  251|       |      const std::string* v = std::get_if<std::string>(&value);
  252|       |      T out;
  253|       |      if (v && out.ParseFromString(*v)) return out;
  254|       |      return std::nullopt;
  255|       |    } else if constexpr (is_dynamic_container_v<T>) {
  256|       |      if constexpr (is_bytevector_v<T>) {
  257|       |        const std::string* v = std::get_if<std::string>(&value);
  258|       |        if (v) {
  259|       |          T out;
  260|       |          out.resize(v->size());
  261|       |          std::memcpy(out.data(), v->data(), v->size());
  262|       |          return out;
  263|       |        }
  264|       |      }
  265|       |
  266|       |      auto elems = Subs();
  267|       |      if (!elems) return std::nullopt;
  268|       |
  269|       |      T out;
  270|       |      for (const auto& elem : *elems) {
  271|       |        if (auto inner = elem.ToCorpus<typename T::value_type>()) {
  272|       |          out.insert(out.end(), *std::move(inner));
  273|       |        } else {
  274|       |          return std::nullopt;
  275|       |        }
  276|       |      }
  277|       |      return out;
  278|       |    } else {
  279|       |      // Must be a tuple like object.
  280|       |      auto elems = Subs();
  281|       |      if (!elems || elems->size() != std::tuple_size_v<T>) return std::nullopt;
  282|       |      auto it = elems->begin();
  283|       |      auto parts = ApplyIndex<std::tuple_size_v<T>>([&](auto... I) {
  284|       |        return std::tuple{it++->ToCorpus<std::tuple_element_t<I, T>>()...};
  285|       |      });
  286|       |      return std::apply(
  287|       |          [&](auto&... part) -> std::optional<T> {
  288|       |            if ((!part || ...)) return std::nullopt;
  289|       |            return T{*std::move(part)...};
  290|       |          },
  291|       |          parts);
  292|       |    }
  293|  1.20k|  }
_ZNK8fuzztest8internal8IRObject9GetScalarINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDav:
   90|  1.20k|  auto GetScalar() const {
   91|       |    if constexpr (std::is_enum_v<T>) {
   92|       |      auto inner = GetScalar<std::underlying_type_t<T>>();
   93|       |      return inner ? std::optional(static_cast<T>(*inner)) : std::nullopt;
   94|       |    } else if constexpr (std::is_integral_v<T>) {
   95|       |      const uint64_t* i = std::get_if<uint64_t>(&value);
   96|       |      return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
   97|       |    } else if constexpr (std::is_same_v<float, T> ||
   98|       |                         std::is_same_v<double, T>) {
   99|       |      const double* i = std::get_if<double>(&value);
  100|       |      return i != nullptr ? std::optional(static_cast<T>(*i)) : std::nullopt;
  101|  1.20k|    } else if constexpr (std::is_same_v<std::string, T>) {
  102|  1.20k|      std::optional<absl::string_view> out;
  103|  1.20k|      if (const auto* s = std::get_if<std::string>(&value)) {
  ------------------
  |  Branch (103:23): [True: 1.18k, False: 21]
  ------------------
  104|  1.18k|        out = *s;
  105|  1.18k|      }
  106|  1.20k|      return out;
  107|  1.20k|    }
  108|  1.20k|  }
_ZZNK8fuzztest8internal8IRObject8ToCorpusINSt3__15tupleIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEEENS3_8optionalIT_EEvENKUlDpRT_E_clIJNSC_ISA_EEEEENSC_ISB_EESH_:
  287|  1.20k|          [&](auto&... part) -> std::optional<T> {
  288|  1.20k|            if ((!part || ...)) return std::nullopt;
  ------------------
  |  Branch (288:18): [True: 21, False: 1.18k]
  ------------------
  289|  1.18k|            return T{*std::move(part)...};
  290|  1.20k|          },
_ZN8fuzztest8internal8IRObjectC2Ev:
   76|  46.8k|  IRObject() = default;

_Z6PrefixRKN4absl12lts_202401166StatusENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
   17|  1.18k|absl::Status Prefix(const absl::Status& status, absl::string_view prefix) {
   18|  1.18k|  if (status.ok() || prefix.empty()) return status;
  ------------------
  |  Branch (18:7): [True: 1.18k, False: 0]
  |  Branch (18:22): [True: 0, False: 0]
  ------------------
   19|      0|  return SetMessage(status, absl::StrCat(prefix, " >> ", status.message()));
   20|  1.18k|}

_ZN7testing7MessagelsIKcEERS0_RKPT_:
  182|     42|  inline Message& operator<<(T* const& pointer) {  // NOLINT
  183|     42|    if (pointer == nullptr) {
  ------------------
  |  Branch (183:9): [True: 0, False: 42]
  ------------------
  184|      0|      *ss_ << "(null)";
  185|     42|    } else {
  186|     42|      *ss_ << pointer;
  187|     42|    }
  188|     42|    return *this;
  189|     42|  }
_ZN7testing8internal18StreamableToStringIiEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKT_:
  243|      6|std::string StreamableToString(const T& streamable) {
  244|      6|  return (Message() << streamable).GetString();
  245|      6|}
_ZN7testing7MessagelsIiEERS0_RKT_:
  132|      6|  inline Message& operator<<(const T& val) {
  133|       |        // Some libraries overload << for STL containers.  These
  134|       |    // overloads are defined in the global namespace instead of ::std.
  135|       |    //
  136|       |    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
  137|       |    // overloads are visible in either the std namespace or the global
  138|       |    // namespace, but not other namespaces, including the testing
  139|       |    // namespace which Google Test's Message class is in.
  140|       |    //
  141|       |    // To allow STL containers (and other types that has a << operator
  142|       |    // defined in the global namespace) to be used in Google Test
  143|       |    // assertions, testing::Message must access the custom << operator
  144|       |    // from the global namespace.  With this using declaration,
  145|       |    // overloads of << defined in the global namespace and those
  146|       |    // visible via Koenig lookup are both exposed in this function.
  147|      6|    using ::operator<<;
  148|      6|    *ss_ << val;
  149|      6|    return *this;
  150|      6|  }
_ZN7testing7MessagelsIA7_cEERS0_RKT_:
  132|     42|  inline Message& operator<<(const T& val) {
  133|       |        // Some libraries overload << for STL containers.  These
  134|       |    // overloads are defined in the global namespace instead of ::std.
  135|       |    //
  136|       |    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
  137|       |    // overloads are visible in either the std namespace or the global
  138|       |    // namespace, but not other namespaces, including the testing
  139|       |    // namespace which Google Test's Message class is in.
  140|       |    //
  141|       |    // To allow STL containers (and other types that has a << operator
  142|       |    // defined in the global namespace) to be used in Google Test
  143|       |    // assertions, testing::Message must access the custom << operator
  144|       |    // from the global namespace.  With this using declaration,
  145|       |    // overloads of << defined in the global namespace and those
  146|       |    // visible via Koenig lookup are both exposed in this function.
  147|     42|    using ::operator<<;
  148|     42|    *ss_ << val;
  149|     42|    return *this;
  150|     42|  }
_ZN7testing7MessagelsIcEERS0_RKT_:
  132|    828|  inline Message& operator<<(const T& val) {
  133|       |        // Some libraries overload << for STL containers.  These
  134|       |    // overloads are defined in the global namespace instead of ::std.
  135|       |    //
  136|       |    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
  137|       |    // overloads are visible in either the std namespace or the global
  138|       |    // namespace, but not other namespaces, including the testing
  139|       |    // namespace which Google Test's Message class is in.
  140|       |    //
  141|       |    // To allow STL containers (and other types that has a << operator
  142|       |    // defined in the global namespace) to be used in Google Test
  143|       |    // assertions, testing::Message must access the custom << operator
  144|       |    // from the global namespace.  With this using declaration,
  145|       |    // overloads of << defined in the global namespace and those
  146|       |    // visible via Koenig lookup are both exposed in this function.
  147|    828|    using ::operator<<;
  148|    828|    *ss_ << val;
  149|    828|    return *this;
  150|    828|  }
_ZN7testing8internal18StreamableToStringIPcEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKT_:
  243|     28|std::string StreamableToString(const T& streamable) {
  244|     28|  return (Message() << streamable).GetString();
  245|     28|}
_ZN7testing7MessagelsIcEERS0_RKPT_:
  182|     28|  inline Message& operator<<(T* const& pointer) {  // NOLINT
  183|     28|    if (pointer == nullptr) {
  ------------------
  |  Branch (183:9): [True: 0, False: 28]
  ------------------
  184|      0|      *ss_ << "(null)";
  185|     28|    } else {
  186|     28|      *ss_ << pointer;
  187|     28|    }
  188|     28|    return *this;
  189|     28|  }

_ZNK7testing8TestInfo15test_suite_nameEv:
  541|      4|  const char* test_suite_name() const { return test_suite_name_.c_str(); }
_ZNK7testing8TestInfo4nameEv:
  549|      8|  const char* name() const { return name_.c_str(); }
_ZN7testing8UnitTest4implEv:
 1267|     48|  internal::UnitTestImpl* impl() { return impl_; }
_ZNK7testing9TestSuite14test_info_listEv:
  762|      2|  const std::vector<TestInfo*>& test_info_list() const {
  763|      2|    return test_info_list_;
  764|      2|  }
_ZN7testing10TestResult19set_start_timestampEl:
  468|      2|  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
_ZN7testing9TestSuite13ShouldRunTestEPKNS_8TestInfoE:
  839|      4|  static bool ShouldRunTest(const TestInfo* test_info) {
  840|      4|    return test_info->should_run();
  841|      4|  }
_ZN7testing9TestSuite17RunSetUpTestSuiteEv:
  793|      2|  void RunSetUpTestSuite() {
  794|      2|    if (set_up_tc_ != nullptr) {
  ------------------
  |  Branch (794:9): [True: 0, False: 2]
  ------------------
  795|      0|      (*set_up_tc_)();
  796|      0|    }
  797|      2|  }
_ZNK7testing9TestSuite18ad_hoc_test_resultEv:
  752|      4|  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
_ZN7testing8TestInfo15ClearTestResultEPS0_:
  639|      2|  static void ClearTestResult(TestInfo* test_info) {
  640|      2|    test_info->result_.Clear();
  641|      2|  }
_ZNK7testing9TestSuite4nameEv:
  695|      4|  const char* name() const { return name_.c_str(); }
_ZNK7testing9TestSuite10type_paramEv:
  699|      2|  const char* type_param() const {
  700|      2|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (700:9): [True: 0, False: 2]
  ------------------
  701|      2|    return nullptr;
  702|      2|  }
_ZNK7testing9TestSuite10should_runEv:
  705|      4|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10should_runEv:
  590|      4|  bool should_run() const { return should_run_; }
_ZNK7testing8TestInfo10type_paramEv:
  553|      2|  const char* type_param() const {
  554|      2|    if (type_param_ != nullptr) return type_param_->c_str();
  ------------------
  |  Branch (554:9): [True: 0, False: 2]
  ------------------
  555|      2|    return nullptr;
  556|      2|  }
_ZNK7testing8UnitTest4implEv:
 1268|      4|  const internal::UnitTestImpl* impl() const { return impl_; }
_ZN7testing9TestSuite20ClearTestSuiteResultEPS0_:
  781|      2|  static void ClearTestSuiteResult(TestSuite* test_suite) {
  782|      2|    test_suite->ClearResult();
  783|      2|  }
_ZN7testing9TestSuite14set_should_runEb:
  771|      4|  void set_should_run(bool should) { should_run_ = should; }
_ZN7testing9TestSuite14test_info_listEv:
  759|      6|  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
_ZN7testing17TestEventListener16OnTestSuiteStartERKNS_9TestSuiteE:
  946|      2|  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}

_ZN7testing8internal8FilePathC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
   74|      2|  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
   75|      2|    Normalize();
   76|      2|  }
_ZNK7testing8internal8FilePath7IsEmptyEv:
  118|      4|  bool IsEmpty() const { return pathname_.empty(); }
_ZN7testing8internal8FilePathC2Ev:
   71|      2|  FilePath() : pathname_("") {}
_ZN7testing8internal8FilePath3SetERKS1_:
   83|      2|  void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }

_ZN7testing8internal6RandomC2Ej:
  859|      2|  explicit Random(uint32_t seed) : state_(seed) {}
_ZN7testing8internal9GetTypeIdINS_4TestEEEPKvv:
  419|      2|TypeId GetTypeId() {
  420|       |  // The compiler is required to allocate a different
  421|       |  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
  422|       |  // the template.  Therefore, the address of dummy_ is guaranteed to
  423|       |  // be unique.
  424|      2|  return &(TypeIdHelper<T>::dummy_);
  425|      2|}

_ZN7testing8internal30ParameterizedTestSuiteRegistry13RegisterTestsEv:
  732|      2|  void RegisterTests() {
  733|      2|    for (auto& test_suite_info : test_suite_infos_) {
  ------------------
  |  Branch (733:32): [True: 0, False: 2]
  ------------------
  734|      0|      test_suite_info->RegisterTests();
  735|      0|    }
  736|      2|  }
_ZN7testing8internal30ParameterizedTestSuiteRegistryC2Ev:
  694|      2|  ParameterizedTestSuiteRegistry() = default;

_ZN7testing8internal7ToUpperEc:
 1971|    828|inline char ToUpper(char ch) {
 1972|    828|  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
 1973|    828|}
_ZN7testing8internal5posix6GetEnvEPKc:
 2122|     62|inline const char* GetEnv(const char* name) {
 2123|       |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
 2124|       |    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||               \
 2125|       |    defined(GTEST_OS_QURT)
 2126|       |  // We are on an embedded platform, which has no environment variables.
 2127|       |  static_cast<void>(name);  // To prevent 'unused argument' warning.
 2128|       |  return nullptr;
 2129|       |#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
 2130|       |  // Environment variables which we programmatically clear will be set to the
 2131|       |  // empty string rather than unset (NULL).  Handle that case.
 2132|       |  const char* const env = getenv(name);
 2133|       |  return (env != nullptr && env[0] != '\0') ? env : nullptr;
 2134|       |#else
 2135|     62|  return getenv(name);
 2136|     62|#endif
 2137|     62|}
_ZN7testing8internal5posix10StrCaseCmpEPKcS3_:
 2059|      2|inline int StrCaseCmp(const char* s1, const char* s2) {
 2060|      2|  return strcasecmp(s1, s2);
 2061|      2|}
_ZN7testing8internal5MutexC2Ev:
 1706|     10|  Mutex() {
 1707|     10|    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
  ------------------
  |  | 1092|     10|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 10]
  |  |  ------------------
  |  | 1093|     10|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1708|     10|    has_owner_ = false;
 1709|     10|  }
_ZN7testing8internal5posix6IsATTYEi:
 2065|      2|inline int IsATTY(int fd) {
 2066|       |  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
 2067|       |  // to a file on Linux), which is unexpected, so save the previous value, and
 2068|       |  // restore it after the call.
 2069|      2|  int savedErrno = errno;
 2070|      2|  int isAttyValue = DoIsATTY(fd);
 2071|      2|  errno = savedErrno;
 2072|       |
 2073|      2|  return isAttyValue;
 2074|      2|}
_ZN7testing8internal5posix8DoIsATTYEi:
 2058|      2|inline int DoIsATTY(int fd) { return isatty(fd); }
_ZN7testing8internal5posix6FileNoEP8_IO_FILE:
 2021|      2|inline int FileNo(FILE* file) { return fileno(file); }
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEEC2ERKS3_:
 1761|      2|      : key_(CreateKey()),
 1762|      2|        default_factory_(new InstanceValueHolderFactory(value)) {}
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE9CreateKeyEv:
 1793|      2|  static pthread_key_t CreateKey() {
 1794|      2|    pthread_key_t key;
 1795|       |    // When a thread exits, DeleteThreadLocalValue() will be called on
 1796|       |    // the object managed for that thread.
 1797|      2|    GTEST_CHECK_POSIX_SUCCESS_(
  ------------------
  |  | 1092|      2|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 2]
  |  |  ------------------
  |  | 1093|      2|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1798|      2|        pthread_key_create(&key, &DeleteThreadLocalValue));
 1799|      2|    return key;
 1800|      2|  }
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE26InstanceValueHolderFactoryC2ERKS3_:
 1839|      2|    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
_ZN7testing8internal11ThreadLocalIPNS_31TestPartResultReporterInterfaceEE18ValueHolderFactoryC2Ev:
 1817|      2|    ValueHolderFactory() = default;
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEEC2Ev:
 1759|      2|      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE9CreateKeyEv:
 1793|      2|  static pthread_key_t CreateKey() {
 1794|      2|    pthread_key_t key;
 1795|       |    // When a thread exits, DeleteThreadLocalValue() will be called on
 1796|       |    // the object managed for that thread.
 1797|      2|    GTEST_CHECK_POSIX_SUCCESS_(
  ------------------
  |  | 1092|      2|  if (const int gtest_error = (posix_call))    \
  |  |  ------------------
  |  |  |  Branch (1092:17): [True: 0, False: 2]
  |  |  ------------------
  |  | 1093|      2|  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
 1798|      2|        pthread_key_create(&key, &DeleteThreadLocalValue));
 1799|      2|    return key;
 1800|      2|  }
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE25DefaultValueHolderFactoryC2Ev:
 1828|      2|    DefaultValueHolderFactory() = default;
_ZN7testing8internal11ThreadLocalINSt3__16vectorINS0_9TraceInfoENS2_9allocatorIS4_EEEEE18ValueHolderFactoryC2Ev:
 1817|      2|    ValueHolderFactory() = default;

_ZN7testing8internal29ParseInternalRunDeathTestFlagEv:
 1531|      2|InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
 1532|      2|  if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr;
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (1532:7): [True: 2, False: 0]
  ------------------
 1533|       |
 1534|       |  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
 1535|       |  // can use it here.
 1536|      0|  int line = -1;
 1537|      0|  int index = -1;
 1538|      0|  ::std::vector< ::std::string> fields;
 1539|      0|  SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
  ------------------
  |  | 2293|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 1540|      0|  int write_fd = -1;
 1541|       |
 1542|       |#ifdef GTEST_OS_WINDOWS
 1543|       |
 1544|       |  unsigned int parent_process_id = 0;
 1545|       |  size_t write_handle_as_size_t = 0;
 1546|       |  size_t event_handle_as_size_t = 0;
 1547|       |
 1548|       |  if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) ||
 1549|       |      !ParseNaturalNumber(fields[2], &index) ||
 1550|       |      !ParseNaturalNumber(fields[3], &parent_process_id) ||
 1551|       |      !ParseNaturalNumber(fields[4], &write_handle_as_size_t) ||
 1552|       |      !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
 1553|       |    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1554|       |                   GTEST_FLAG_GET(internal_run_death_test));
 1555|       |  }
 1556|       |  write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
 1557|       |                                     event_handle_as_size_t);
 1558|       |
 1559|       |#elif defined(GTEST_OS_FUCHSIA)
 1560|       |
 1561|       |  if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
 1562|       |      !ParseNaturalNumber(fields[2], &index)) {
 1563|       |    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1564|       |                   GTEST_FLAG_GET(internal_run_death_test));
 1565|       |  }
 1566|       |
 1567|       |#else
 1568|       |
 1569|      0|  if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) ||
  ------------------
  |  Branch (1569:7): [True: 0, False: 0]
  |  Branch (1569:29): [True: 0, False: 0]
  ------------------
 1570|      0|      !ParseNaturalNumber(fields[2], &index) ||
  ------------------
  |  Branch (1570:7): [True: 0, False: 0]
  ------------------
 1571|      0|      !ParseNaturalNumber(fields[3], &write_fd)) {
  ------------------
  |  Branch (1571:7): [True: 0, False: 0]
  ------------------
 1572|      0|    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
 1573|      0|                   GTEST_FLAG_GET(internal_run_death_test));
  ------------------
  |  | 2293|      0|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 1574|      0|  }
 1575|       |
 1576|      0|#endif  // GTEST_OS_WINDOWS
 1577|       |
 1578|      0|  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
 1579|      2|}

_ZN7testing8internal8FilePath13GetCurrentDirEv:
  101|      2|FilePath FilePath::GetCurrentDir() {
  102|       |#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
  103|       |    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) ||           \
  104|       |    defined(GTEST_OS_ESP32) || defined(GTEST_OS_XTENSA) ||                 \
  105|       |    defined(GTEST_OS_QURT) || defined(GTEST_OS_NXP_QN9090) ||              \
  106|       |    defined(GTEST_OS_NRF52)
  107|       |  // These platforms do not have a current directory, so we just return
  108|       |  // something reasonable.
  109|       |  return FilePath(kCurrentDirectoryString);
  110|       |#elif defined(GTEST_OS_WINDOWS)
  111|       |  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
  112|       |  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
  113|       |#else
  114|      2|  char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
  115|      2|  char* result = getcwd(cwd, sizeof(cwd));
  116|       |#ifdef GTEST_OS_NACL
  117|       |  // getcwd will likely fail in NaCl due to the sandbox, so return something
  118|       |  // reasonable. The user may have provided a shim implementation for getcwd,
  119|       |  // however, so fallback only when failure is detected.
  120|       |  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
  121|       |#endif  // GTEST_OS_NACL
  122|      2|  return FilePath(result == nullptr ? "" : cwd);
  ------------------
  |  Branch (122:19): [True: 0, False: 2]
  ------------------
  123|      2|#endif  // GTEST_OS_WINDOWS_MOBILE
  124|      2|}
_ZN7testing8internal8FilePath9NormalizeEv:
  386|      2|void FilePath::Normalize() {
  387|      2|  auto out = pathname_.begin();
  388|       |
  389|      2|  auto i = pathname_.cbegin();
  390|       |#ifdef GTEST_OS_WINDOWS
  391|       |  // UNC paths are treated specially
  392|       |  if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
  393|       |      IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {
  394|       |    *(out++) = kPathSeparator;
  395|       |    *(out++) = kPathSeparator;
  396|       |  }
  397|       |#endif
  398|     82|  while (i != pathname_.end()) {
  ------------------
  |  Branch (398:10): [True: 80, False: 2]
  ------------------
  399|     80|    const char character = *i;
  400|     80|    if (!IsPathSeparator(character)) {
  ------------------
  |  Branch (400:9): [True: 74, False: 6]
  ------------------
  401|     74|      *(out++) = character;
  402|     74|    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
  ------------------
  |  Branch (402:16): [True: 2, False: 4]
  |  Branch (402:16): [True: 6, False: 0]
  |  Branch (402:44): [True: 4, False: 0]
  ------------------
  403|      6|      *(out++) = kPathSeparator;
  404|      6|    }
  405|     80|    ++i;
  406|     80|  }
  407|       |
  408|      2|  pathname_.erase(out, pathname_.end());
  409|      2|}
gtest-all.cc:_ZN7testing8internalL15IsPathSeparatorEc:
   92|     80|static bool IsPathSeparator(char c) {
   93|       |#if GTEST_HAS_ALT_PATH_SEP_
   94|       |  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
   95|       |#else
   96|     80|  return c == kPathSeparator;
   97|     80|#endif
   98|     80|}

_ZN7testing8internal15GetUnitTestImplEv:
  966|     34|inline UnitTestImpl* GetUnitTestImpl() {
  967|     34|  return UnitTest::GetInstance()->impl();
  968|     34|}
_ZN7testing8internal12UnitTestImpl17current_test_infoEv:
  766|      2|  TestInfo* current_test_info() { return current_test_info_; }
_ZN7testing8internal12UnitTestImpl9listenersEv:
  608|     12|  TestEventListeners* listeners() { return &listeners_; }
_ZN7testing8internal12UnitTestImpl33ignored_parameterized_test_suitesEv:
  701|      2|  std::set<std::string>* ignored_parameterized_test_suites() {
  702|      2|    return &ignored_parameterized_test_suites_;
  703|      2|  }
_ZN7testing8internal14GTestFlagSaverC2Ev:
  143|      2|  GTestFlagSaver() {
  144|      2|    also_run_disabled_tests_ = GTEST_FLAG_GET(also_run_disabled_tests);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  145|      2|    break_on_failure_ = GTEST_FLAG_GET(break_on_failure);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  146|      2|    catch_exceptions_ = GTEST_FLAG_GET(catch_exceptions);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  147|      2|    color_ = GTEST_FLAG_GET(color);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  148|      2|    death_test_style_ = GTEST_FLAG_GET(death_test_style);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  149|      2|    death_test_use_fork_ = GTEST_FLAG_GET(death_test_use_fork);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  150|      2|    fail_fast_ = GTEST_FLAG_GET(fail_fast);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  151|      2|    filter_ = GTEST_FLAG_GET(filter);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  152|      2|    internal_run_death_test_ = GTEST_FLAG_GET(internal_run_death_test);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  153|      2|    list_tests_ = GTEST_FLAG_GET(list_tests);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  154|      2|    output_ = GTEST_FLAG_GET(output);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  155|      2|    brief_ = GTEST_FLAG_GET(brief);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  156|      2|    print_time_ = GTEST_FLAG_GET(print_time);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  157|      2|    print_utf8_ = GTEST_FLAG_GET(print_utf8);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  158|      2|    random_seed_ = GTEST_FLAG_GET(random_seed);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  159|      2|    repeat_ = GTEST_FLAG_GET(repeat);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  160|      2|    recreate_environments_when_repeating_ =
  161|      2|        GTEST_FLAG_GET(recreate_environments_when_repeating);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  162|      2|    shuffle_ = GTEST_FLAG_GET(shuffle);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  163|      2|    stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  164|      2|    stream_result_to_ = GTEST_FLAG_GET(stream_result_to);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  165|      2|    throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  166|      2|  }
_ZNK7testing8internal12UnitTestImpl18current_test_suiteEv:
  765|      2|  const TestSuite* current_test_suite() const { return current_test_suite_; }
_ZN7testing8internal12UnitTestImpl11AddTestInfoEPFvvES3_PNS_8TestInfoE:
  674|      2|                   TestInfo* test_info) {
  675|      2|#if GTEST_HAS_FILE_SYSTEM
  676|       |    // In order to support thread-safe death tests, we need to
  677|       |    // remember the original working directory when the test program
  678|       |    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
  679|       |    // the user may have changed the current directory before calling
  680|       |    // RUN_ALL_TESTS().  Therefore we capture the current directory in
  681|       |    // AddTestInfo(), which is called to register a TEST or TEST_F
  682|       |    // before main() is reached.
  683|      2|    if (original_working_dir_.IsEmpty()) {
  ------------------
  |  Branch (683:9): [True: 2, False: 0]
  ------------------
  684|      2|      original_working_dir_.Set(FilePath::GetCurrentDir());
  685|      4|      GTEST_CHECK_(!original_working_dir_.IsEmpty())
  ------------------
  |  | 1079|      2|  GTEST_AMBIGUOUS_ELSE_BLOCKER_               \
  |  |  ------------------
  |  |  |  |  712|      4|  switch (0)                          \
  |  |  |  |  713|      4|  case 0:                             \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (713:3): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  714|      2|  default:  // NOLINT
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (714:3): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1080|      2|  if (::testing::internal::IsTrue(condition)) \
  |  |  ------------------
  |  |  |  Branch (1080:7): [True: 2, False: 0]
  |  |  ------------------
  |  | 1081|      2|    ;                                         \
  |  | 1082|      2|  else                                        \
  |  | 1083|      2|    GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
  |  |  ------------------
  |  |  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  |  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  |  |  | 1056|      0|      .GetStream()
  |  |  ------------------
  ------------------
  686|      4|          << "Failed to get the current working directory.";
  687|      2|    }
  688|      2|#endif  // GTEST_HAS_FILE_SYSTEM
  689|       |
  690|      2|    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
  691|      2|                 set_up_tc, tear_down_tc)
  692|      2|        ->AddTestInfo(test_info);
  693|      2|  }
_ZN7testing8internal12UnitTestImpl21set_current_test_infoEPNS_8TestInfoE:
  720|      2|  void set_current_test_info(TestInfo* a_current_test_info) {
  721|      2|    current_test_info_ = a_current_test_info;
  722|      2|  }
_ZN7testing8internal12UnitTestImpl22set_current_test_suiteEPNS_9TestSuiteE:
  713|      2|  void set_current_test_suite(TestSuite* a_current_test_suite) {
  714|      2|    current_test_suite_ = a_current_test_suite;
  715|      2|  }
_ZN7testing8internal12UnitTestImpl19GetMutableSuiteCaseEi:
  602|      2|  TestSuite* GetMutableSuiteCase(int i) {
  603|      2|    const int index = GetElementOr(test_suite_indices_, i, -1);
  604|      2|    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
  ------------------
  |  Branch (604:12): [True: 0, False: 2]
  ------------------
  605|      2|  }
_ZN7testing8internal12UnitTestImpl20set_catch_exceptionsEb:
  842|      2|  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
_ZN7testing8internal12UnitTestImpl34InitDeathTestSubprocessControlInfoEv:
  782|      2|  void InitDeathTestSubprocessControlInfo() {
  783|      2|    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  784|      2|  }
_ZN7testing8internal21GetRandomSeedFromFlagEi:
  113|      2|inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
  114|      2|  const unsigned int raw_seed =
  115|      2|      (random_seed_flag == 0) ? static_cast<unsigned int>(GetTimeInMillis())
  ------------------
  |  Branch (115:7): [True: 2, False: 0]
  ------------------
  116|      2|                              : static_cast<unsigned int>(random_seed_flag);
  117|       |
  118|       |  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  119|       |  // it's easy to type.
  120|      2|  const int normalized_seed =
  121|      2|      static_cast<int>((raw_seed - 1U) %
  122|      2|                       static_cast<unsigned int>(kMaxRandomSeed)) +
  123|      2|      1;
  124|      2|  return normalized_seed;
  125|      2|}
_ZN7testing8internal12UnitTestImpl23ClearNonAdHocTestResultEv:
  739|      2|  void ClearNonAdHocTestResult() {
  740|      2|    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
  741|      2|  }
_ZN7testing8internal18OsStackTraceGetterC2Ev:
  439|      2|  OsStackTraceGetter() = default;
_ZN7testing8internal27OsStackTraceGetterInterfaceC2Ev:
  410|      2|  OsStackTraceGetterInterface() = default;
_ZN7testing8internal12GetElementOrIiEET_RKNSt3__16vectorIS2_NS3_9allocatorIS2_EEEEiS2_:
  294|      4|inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
  295|      4|  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
  ------------------
  |  Branch (295:11): [True: 0, False: 4]
  |  Branch (295:20): [True: 0, False: 4]
  ------------------
  296|      4|                                                    : v[static_cast<size_t>(i)];
  297|      4|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  287|      2|void ForEach(const Container& c, Functor functor) {
  288|      2|  std::for_each(c.begin(), c.end(), functor);
  289|      2|}
_ZN7testing8internal7CountIfINSt3__16vectorIPNS_9TestSuiteENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_:
  275|      2|inline int CountIf(const Container& c, Predicate predicate) {
  276|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  277|       |  // Solaris has a non-standard signature.
  278|      2|  int count = 0;
  279|      4|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 2, False: 2]
  ------------------
  280|      2|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 2, False: 0]
  ------------------
  281|      2|  }
  282|      2|  return count;
  283|      2|}
_ZN7testing8internal7CountIfINSt3__16vectorINS_14TestPartResultENS2_9allocatorIS4_EEEEPFbRKS4_EEEiRKT_T0_:
  275|     14|inline int CountIf(const Container& c, Predicate predicate) {
  276|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  277|       |  // Solaris has a non-standard signature.
  278|     14|  int count = 0;
  279|     14|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 0, False: 14]
  ------------------
  280|      0|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 0, False: 0]
  ------------------
  281|      0|  }
  282|     14|  return count;
  283|     14|}
_ZNK7testing8internal12UnitTestImpl16catch_exceptionsEv:
  835|     10|  bool catch_exceptions() const { return catch_exceptions_; }
_ZN7testing8internal7CountIfINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFbPKS4_EEEiRKT_T0_:
  275|      4|inline int CountIf(const Container& c, Predicate predicate) {
  276|       |  // Implemented as an explicit loop since std::count_if() in libCstd on
  277|       |  // Solaris has a non-standard signature.
  278|      4|  int count = 0;
  279|      8|  for (auto it = c.begin(); it != c.end(); ++it) {
  ------------------
  |  Branch (279:29): [True: 4, False: 4]
  ------------------
  280|      4|    if (predicate(*it)) ++count;
  ------------------
  |  Branch (280:9): [True: 4, False: 0]
  ------------------
  281|      4|  }
  282|      4|  return count;
  283|      4|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_8TestInfoENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  287|      2|void ForEach(const Container& c, Functor functor) {
  288|      2|  std::for_each(c.begin(), c.end(), functor);
  289|      2|}
_ZN7testing8internal7ForEachINSt3__16vectorIPNS_11EnvironmentENS2_9allocatorIS5_EEEEPFvS5_EEEvRKT_T0_:
  287|      2|void ForEach(const Container& c, Functor functor) {
  288|      2|  std::for_each(c.begin(), c.end(), functor);
  289|      2|}

_ZN7testing8internal16BoolFromGTestEnvEPKcb:
 1324|     24|bool BoolFromGTestEnv(const char* flag, bool default_value) {
 1325|       |#if defined(GTEST_GET_BOOL_FROM_ENV_)
 1326|       |  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
 1327|       |#else
 1328|     24|  const std::string env_var = FlagToEnvVar(flag);
 1329|     24|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1330|     24|  return string_value == nullptr ? default_value
  ------------------
  |  Branch (1330:10): [True: 24, False: 0]
  ------------------
 1331|     24|                                 : strcmp(string_value, "0") != 0;
 1332|     24|#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
 1333|     24|}
_ZN7testing8internal17Int32FromGTestEnvEPKci:
 1338|      6|int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
 1339|       |#if defined(GTEST_GET_INT32_FROM_ENV_)
 1340|       |  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
 1341|       |#else
 1342|      6|  const std::string env_var = FlagToEnvVar(flag);
 1343|      6|  const char* const string_value = posix::GetEnv(env_var.c_str());
 1344|      6|  if (string_value == nullptr) {
  ------------------
  |  Branch (1344:7): [True: 6, False: 0]
  ------------------
 1345|       |    // The environment variable is not set.
 1346|      6|    return default_value;
 1347|      6|  }
 1348|       |
 1349|      0|  int32_t result = default_value;
 1350|      0|  if (!ParseInt32(Message() << "Environment variable " << env_var, string_value,
  ------------------
  |  Branch (1350:7): [True: 0, False: 0]
  ------------------
 1351|      0|                  &result)) {
 1352|      0|    printf("The default value %s is used.\n",
 1353|      0|           (Message() << default_value).GetString().c_str());
 1354|      0|    fflush(stdout);
 1355|      0|    return default_value;
 1356|      0|  }
 1357|       |
 1358|      0|  return result;
 1359|      0|#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
 1360|      0|}
_ZN7testing8internal25OutputFlagAlsoCheckEnvVarEv:
 1370|      2|std::string OutputFlagAlsoCheckEnvVar() {
 1371|      2|  std::string default_value_for_output_flag = "";
 1372|      2|  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
 1373|      2|  if (nullptr != xml_output_file_env) {
  ------------------
  |  Branch (1373:7): [True: 0, False: 2]
  ------------------
 1374|      0|    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
 1375|      0|  }
 1376|      2|  return default_value_for_output_flag;
 1377|      2|}
_ZN7testing8internal18StringFromGTestEnvEPKcS2_:
 1381|     12|const char* StringFromGTestEnv(const char* flag, const char* default_value) {
 1382|       |#if defined(GTEST_GET_STRING_FROM_ENV_)
 1383|       |  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
 1384|       |#else
 1385|     12|  const std::string env_var = FlagToEnvVar(flag);
 1386|     12|  const char* const value = posix::GetEnv(env_var.c_str());
 1387|     12|  return value == nullptr ? default_value : value;
  ------------------
  |  Branch (1387:10): [True: 12, False: 0]
  ------------------
 1388|     12|#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
 1389|     12|}
gtest-all.cc:_ZN7testing8internalL12FlagToEnvVarEPKc:
 1267|     42|static std::string FlagToEnvVar(const char* flag) {
 1268|     42|  const std::string full_flag =
 1269|     42|      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
  ------------------
  |  |  331|     42|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
 1270|       |
 1271|     42|  Message env_var;
 1272|    870|  for (size_t i = 0; i != full_flag.length(); i++) {
  ------------------
  |  Branch (1272:22): [True: 828, False: 42]
  ------------------
 1273|    828|    env_var << ToUpper(full_flag.c_str()[i]);
 1274|    828|  }
 1275|       |
 1276|     42|  return env_var.GetString();
 1277|     42|}

_ZN7testing8internal33GetIgnoredParameterizedTestSuitesEv:
  502|      2|std::set<std::string>* GetIgnoredParameterizedTestSuites() {
  503|      2|  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
  504|      2|}
_ZN7testing8internal34TypeParameterizedTestSuiteRegistry22CheckForInstantiationsEv:
  585|      2|void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
  586|      2|  const auto& ignored = *GetIgnoredParameterizedTestSuites();
  587|      2|  for (const auto& testcase : suites_) {
  ------------------
  |  Branch (587:29): [True: 0, False: 2]
  ------------------
  588|      0|    if (testcase.second.instantiated) continue;
  ------------------
  |  Branch (588:9): [True: 0, False: 0]
  ------------------
  589|      0|    if (ignored.find(testcase.first) != ignored.end()) continue;
  ------------------
  |  Branch (589:9): [True: 0, False: 0]
  ------------------
  590|       |
  591|      0|    std::string message =
  592|      0|        "Type parameterized test suite " + testcase.first +
  593|      0|        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
  594|      0|        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
  595|      0|        "\n\n"
  596|      0|        "Ideally, TYPED_TEST_P definitions should only ever be included as "
  597|      0|        "part of binaries that intend to use them. (As opposed to, for "
  598|      0|        "example, being placed in a library that may be linked in to get other "
  599|      0|        "utilities.)"
  600|      0|        "\n\n"
  601|      0|        "To suppress this error for this test suite, insert the following line "
  602|      0|        "(in a non-header) in the namespace it is defined in:"
  603|      0|        "\n\n"
  604|      0|        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
  605|      0|        testcase.first + ");";
  606|       |
  607|      0|    std::string full_name =
  608|      0|        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
  609|      0|    RegisterTest(  //
  610|      0|        "GoogleTestVerification", full_name.c_str(),
  611|      0|        nullptr,  // No type parameter.
  612|      0|        nullptr,  // No value parameter.
  613|      0|        testcase.second.code_location.file.c_str(),
  614|      0|        testcase.second.code_location.line, [message, testcase] {
  615|      0|          return new FailureTest(testcase.second.code_location, message,
  616|      0|                                 kErrorOnUninstantiatedTypeParameterizedTest);
  617|      0|        });
  618|      0|  }
  619|      2|}
_ZN7testing8internal8GetArgvsEv:
  624|      4|::std::vector<std::string> GetArgvs() {
  625|       |#if defined(GTEST_CUSTOM_GET_ARGVS_)
  626|       |  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
  627|       |  // ::string. This code converts it to the appropriate type.
  628|       |  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
  629|       |  return ::std::vector<std::string>(custom.begin(), custom.end());
  630|       |#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
  631|      4|  return g_argvs;
  632|      4|#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
  633|      4|}
_ZN7testing8internal15UnitTestOptions15GetOutputFormatEv:
  654|      2|std::string UnitTestOptions::GetOutputFormat() {
  655|      2|  std::string s = GTEST_FLAG_GET(output);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  656|      2|  const char* const gtest_output_flag = s.c_str();
  657|      2|  const char* const colon = strchr(gtest_output_flag, ':');
  658|      2|  return (colon == nullptr)
  ------------------
  |  Branch (658:10): [True: 2, False: 0]
  ------------------
  659|      2|             ? std::string(gtest_output_flag)
  660|      2|             : std::string(gtest_output_flag,
  661|      0|                           static_cast<size_t>(colon - gtest_output_flag));
  662|      2|}
_ZN7testing8internal13GetTestTypeIdEv:
  962|      2|TypeId GetTestTypeId() { return GetTypeId<Test>(); }
_ZN7testing8internal35DefaultGlobalTestPartResultReporterC2EPNS0_12UnitTestImplE:
 1025|      2|    : unit_test_(unit_test) {}
_ZN7testing8internal38DefaultPerThreadTestPartResultReporterC2EPNS0_12UnitTestImplE:
 1035|      2|    : unit_test_(unit_test) {}
_ZNK7testing8internal12UnitTestImpl22total_test_suite_countEv:
 1079|      2|int UnitTestImpl::total_test_suite_count() const {
 1080|      2|  return static_cast<int>(test_suites_.size());
 1081|      2|}
_ZNK7testing8internal12UnitTestImpl23test_suite_to_run_countEv:
 1085|      2|int UnitTestImpl::test_suite_to_run_count() const {
 1086|      2|  return CountIf(test_suites_, ShouldRunTestSuite);
 1087|      2|}
_ZNK7testing8internal12UnitTestImpl17test_to_run_countEv:
 1126|      2|int UnitTestImpl::test_to_run_count() const {
 1127|      2|  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
 1128|      2|}
_ZN7testing8internal15GetTimeInMillisEv:
 1174|      8|TimeInMillis GetTimeInMillis() {
 1175|      8|  return std::chrono::duration_cast<std::chrono::milliseconds>(
 1176|      8|             std::chrono::system_clock::now() -
 1177|      8|             std::chrono::system_clock::from_time_t(0))
 1178|      8|      .count();
 1179|      8|}
_ZN7testing8internal6String13CStringEqualsEPKcS3_:
 1224|      2|bool String::CStringEquals(const char* lhs, const char* rhs) {
 1225|      2|  if (lhs == nullptr) return rhs == nullptr;
  ------------------
  |  Branch (1225:7): [True: 0, False: 2]
  ------------------
 1226|       |
 1227|      2|  if (rhs == nullptr) return false;
  ------------------
  |  Branch (1227:7): [True: 0, False: 2]
  ------------------
 1228|       |
 1229|      2|  return strcmp(lhs, rhs) == 0;
 1230|      2|}
_ZN7testing8internal11SplitStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEcPNS1_6vectorIS7_NS5_IS7_EEEE:
 1252|      8|                 ::std::vector< ::std::string>* dest) {
 1253|      8|  ::std::vector< ::std::string> parsed;
 1254|      8|  ::std::string::size_type pos = 0;
 1255|     12|  while (::testing::internal::AlwaysTrue()) {
  ------------------
  |  Branch (1255:10): [True: 12, False: 0]
  ------------------
 1256|     12|    const ::std::string::size_type colon = str.find(delimiter, pos);
 1257|     12|    if (colon == ::std::string::npos) {
  ------------------
  |  Branch (1257:9): [True: 8, False: 4]
  ------------------
 1258|      8|      parsed.push_back(str.substr(pos));
 1259|      8|      break;
 1260|      8|    } else {
 1261|      4|      parsed.push_back(str.substr(pos, colon - pos));
 1262|      4|      pos = colon + 1;
 1263|      4|    }
 1264|     12|  }
 1265|      8|  dest->swap(parsed);
 1266|      8|}
_ZN7testing7MessageC2Ev:
 1275|    118|Message::Message() : ss_(new ::std::stringstream) {
 1276|       |  // By default, we want there to be enough precision when printing
 1277|       |  // a double to a Message.
 1278|    118|  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
 1279|    118|}
_ZNK7testing7Message9GetStringEv:
 1301|    118|std::string Message::GetString() const {
 1302|    118|  return internal::StringStreamToString(ss_.get());
 1303|    118|}
_ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_:
 2131|      2|bool String::CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
 2132|      2|  if (lhs == nullptr) return rhs == nullptr;
  ------------------
  |  Branch (2132:7): [True: 0, False: 2]
  ------------------
 2133|      2|  if (rhs == nullptr) return false;
  ------------------
  |  Branch (2133:7): [True: 0, False: 2]
  ------------------
 2134|      2|  return posix::StrCaseCmp(lhs, rhs) == 0;
 2135|      2|}
_ZN7testing8internal20StringStreamToStringEPNSt3__118basic_stringstreamIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2216|    118|std::string StringStreamToString(::std::stringstream* ss) {
 2217|    118|  const ::std::string& str = ss->str();
 2218|    118|  const char* const start = str.c_str();
 2219|    118|  const char* const end = start + str.length();
 2220|       |
 2221|    118|  std::string result;
 2222|    118|  result.reserve(static_cast<size_t>(2 * (end - start)));
 2223|  2.79k|  for (const char* ch = start; ch != end; ++ch) {
  ------------------
  |  Branch (2223:32): [True: 2.67k, False: 118]
  ------------------
 2224|  2.67k|    if (*ch == '\0') {
  ------------------
  |  Branch (2224:9): [True: 0, False: 2.67k]
  ------------------
 2225|      0|      result += "\\0";  // Replaces NUL with "\\0";
 2226|  2.67k|    } else {
 2227|  2.67k|      result += *ch;
 2228|  2.67k|    }
 2229|  2.67k|  }
 2230|       |
 2231|    118|  return result;
 2232|    118|}
_ZN7testing10TestResultC2Ev:
 2254|      6|    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
_ZN7testing10TestResult5ClearEv:
 2400|      4|void TestResult::Clear() {
 2401|      4|  test_part_results_.clear();
 2402|      4|  test_properties_.clear();
 2403|      4|  death_test_count_ = 0;
 2404|      4|  elapsed_time_ = 0;
 2405|      4|}
_ZNK7testing10TestResult7SkippedEv:
 2413|      8|bool TestResult::Skipped() const {
 2414|      8|  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
  ------------------
  |  Branch (2414:10): [True: 8, False: 0]
  |  Branch (2414:23): [True: 0, False: 8]
  ------------------
 2415|      8|}
_ZNK7testing10TestResult6FailedEv:
 2418|     10|bool TestResult::Failed() const {
 2419|     10|  for (int i = 0; i < total_part_count(); ++i) {
  ------------------
  |  Branch (2419:19): [True: 0, False: 10]
  ------------------
 2420|      0|    if (GetTestPartResult(i).failed()) return true;
  ------------------
  |  Branch (2420:9): [True: 0, False: 0]
  ------------------
 2421|      0|  }
 2422|     10|  return false;
 2423|     10|}
_ZNK7testing10TestResult15HasFatalFailureEv:
 2431|      6|bool TestResult::HasFatalFailure() const {
 2432|      6|  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
 2433|      6|}
_ZNK7testing10TestResult16total_part_countEv:
 2447|     10|int TestResult::total_part_count() const {
 2448|     10|  return static_cast<int>(test_part_results_.size());
 2449|     10|}
_ZN7testing4TestC2Ev:
 2461|      2|Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {}
  ------------------
  |  | 2291|      2|#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
  ------------------
_ZN7testing4Test5SetUpEv:
 2471|      2|void Test::SetUp() {}
_ZN7testing4Test19HasSameFixtureClassEv:
 2504|      2|bool Test::HasSameFixtureClass() {
 2505|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2506|      2|  const TestSuite* const test_suite = impl->current_test_suite();
 2507|       |
 2508|       |  // Info about the first test in the current test suite.
 2509|      2|  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
 2510|      2|  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
 2511|      2|  const char* const first_test_name = first_test_info->name();
 2512|       |
 2513|       |  // Info about the current test.
 2514|      2|  const TestInfo* const this_test_info = impl->current_test_info();
 2515|      2|  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
 2516|      2|  const char* const this_test_name = this_test_info->name();
 2517|       |
 2518|      2|  if (this_fixture_id != first_fixture_id) {
  ------------------
  |  Branch (2518:7): [True: 0, False: 2]
  ------------------
 2519|       |    // Is the first test defined using TEST?
 2520|      0|    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
 2521|       |    // Is this test defined using TEST?
 2522|      0|    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
 2523|       |
 2524|      0|    if (first_is_TEST || this_is_TEST) {
  ------------------
  |  Branch (2524:9): [True: 0, False: 0]
  |  Branch (2524:26): [True: 0, False: 0]
  ------------------
 2525|       |      // Both TEST and TEST_F appear in same test suite, which is incorrect.
 2526|       |      // Tell the user how to fix this.
 2527|       |
 2528|       |      // Gets the name of the TEST and the name of the TEST_F.  Note
 2529|       |      // that first_is_TEST and this_is_TEST cannot both be true, as
 2530|       |      // the fixture IDs are different for the two tests.
 2531|      0|      const char* const TEST_name =
 2532|      0|          first_is_TEST ? first_test_name : this_test_name;
  ------------------
  |  Branch (2532:11): [True: 0, False: 0]
  ------------------
 2533|      0|      const char* const TEST_F_name =
 2534|      0|          first_is_TEST ? this_test_name : first_test_name;
  ------------------
  |  Branch (2534:11): [True: 0, False: 0]
  ------------------
 2535|       |
 2536|      0|      ADD_FAILURE()
  ------------------
  |  | 1735|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1339|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1333|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1329|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1330|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2537|      0|          << "All tests in the same test suite must use the same test fixture\n"
 2538|      0|          << "class, so mixing TEST_F and TEST in the same test suite is\n"
 2539|      0|          << "illegal.  In test suite " << this_test_info->test_suite_name()
 2540|      0|          << ",\n"
 2541|      0|          << "test " << TEST_F_name << " is defined using TEST_F but\n"
 2542|      0|          << "test " << TEST_name << " is defined using TEST.  You probably\n"
 2543|      0|          << "want to change the TEST to TEST_F or move it to another test\n"
 2544|      0|          << "case.";
 2545|      0|    } else {
 2546|       |      // Two fixture classes with the same name appear in two different
 2547|       |      // namespaces, which is not allowed. Tell the user how to fix this.
 2548|      0|      ADD_FAILURE()
  ------------------
  |  | 1735|      0|#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
  |  |  ------------------
  |  |  |  | 1339|      0|  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1333|      0|  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1329|      0|  ::testing::internal::AssertHelper(result_type, file, line, message) = \
  |  |  |  |  |  |  |  | 1330|      0|      ::testing::Message()
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2549|      0|          << "All tests in the same test suite must use the same test fixture\n"
 2550|      0|          << "class.  However, in test suite "
 2551|      0|          << this_test_info->test_suite_name() << ",\n"
 2552|      0|          << "you defined test " << first_test_name << " and test "
 2553|      0|          << this_test_name << "\n"
 2554|      0|          << "using two different test fixture classes.  This can happen if\n"
 2555|      0|          << "the two classes are from different namespaces or translation\n"
 2556|      0|          << "units and have the same name.  You should probably rename one\n"
 2557|      0|          << "of the classes to put the tests into different test suites.";
 2558|      0|    }
 2559|      0|    return false;
 2560|      0|  }
 2561|       |
 2562|      2|  return true;
 2563|      2|}
_ZN7testing4Test3RunEv:
 2677|      2|void Test::Run() {
 2678|      2|  if (!HasSameFixtureClass()) return;
  ------------------
  |  Branch (2678:7): [True: 0, False: 2]
  ------------------
 2679|       |
 2680|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2681|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2682|      2|  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
 2683|       |  // We will run the test only if SetUp() was successful and didn't call
 2684|       |  // GTEST_SKIP().
 2685|      2|  if (!HasFatalFailure() && !IsSkipped()) {
  ------------------
  |  Branch (2685:7): [True: 2, False: 0]
  |  Branch (2685:29): [True: 2, False: 0]
  ------------------
 2686|      2|    impl->os_stack_trace_getter()->UponLeavingGTest();
 2687|      2|    internal::HandleExceptionsInMethodIfSupported(this, &Test::TestBody,
 2688|      2|                                                  "the test body");
 2689|      2|  }
 2690|       |
 2691|       |  // However, we want to clean up as much as possible.  Hence we will
 2692|       |  // always call TearDown(), even if SetUp() or the test body has
 2693|       |  // failed.
 2694|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2695|      2|  internal::HandleExceptionsInMethodIfSupported(this, &Test::TearDown,
 2696|      2|                                                "TearDown()");
 2697|      2|}
_ZN7testing4Test15HasFatalFailureEv:
 2700|      6|bool Test::HasFatalFailure() {
 2701|      6|  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
 2702|      6|}
_ZN7testing4Test9IsSkippedEv:
 2712|      6|bool Test::IsSkipped() {
 2713|      6|  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
 2714|      6|}
_ZN7testing8TestInfoC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PKcSB_NS_8internal12CodeLocationEPKvPNSC_15TestFactoryBaseE:
 2726|      2|    : test_suite_name_(a_test_suite_name),
 2727|       |      // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)
 2728|      2|      name_(a_name.begin(), a_name.end()),
 2729|      2|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2729:19): [True: 0, False: 2]
  ------------------
 2730|      2|      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
  ------------------
  |  Branch (2730:20): [True: 0, False: 2]
  ------------------
 2731|      2|      location_(a_code_location),
 2732|      2|      fixture_class_id_(fixture_class_id),
 2733|      2|      should_run_(false),
 2734|      2|      is_disabled_(false),
 2735|      2|      matches_filter_(false),
 2736|      2|      is_in_another_shard_(false),
 2737|      2|      factory_(factory),
 2738|      2|      result_() {}
_ZN7testing8internal23MakeAndRegisterTestInfoEPKcS2_S2_S2_NS0_12CodeLocationEPKvPFvvES7_PNS0_15TestFactoryBaseE:
 2767|      2|    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
 2768|      2|  TestInfo* const test_info =
 2769|      2|      new TestInfo(test_suite_name, name, type_param, value_param,
 2770|      2|                   code_location, fixture_class_id, factory);
 2771|      2|  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
 2772|      2|  return test_info;
 2773|      2|}
_ZN7testing8internal12UnitTestImpl26RegisterParameterizedTestsEv:
 2796|      2|void UnitTestImpl::RegisterParameterizedTests() {
 2797|      2|  if (!parameterized_tests_registered_) {
  ------------------
  |  Branch (2797:7): [True: 2, False: 0]
  ------------------
 2798|      2|    parameterized_test_registry_.RegisterTests();
 2799|      2|    type_parameterized_test_registry_.CheckForInstantiations();
 2800|      2|    parameterized_tests_registered_ = true;
 2801|      2|  }
 2802|      2|}
_ZN7testing8TestInfo3RunEv:
 2808|      2|void TestInfo::Run() {
 2809|      2|  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 2810|      2|  if (!should_run_) {
  ------------------
  |  Branch (2810:7): [True: 0, False: 2]
  ------------------
 2811|      0|    if (is_disabled_ && matches_filter_) repeater->OnTestDisabled(*this);
  ------------------
  |  Branch (2811:9): [True: 0, False: 0]
  |  Branch (2811:25): [True: 0, False: 0]
  ------------------
 2812|      0|    return;
 2813|      0|  }
 2814|       |
 2815|       |  // Tells UnitTest where to store test result.
 2816|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2817|      2|  impl->set_current_test_info(this);
 2818|       |
 2819|       |  // Notifies the unit test event listeners that a test is about to start.
 2820|      2|  repeater->OnTestStart(*this);
 2821|      2|  result_.set_start_timestamp(internal::GetTimeInMillis());
 2822|      2|  internal::Timer timer;
 2823|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 2824|       |
 2825|       |  // Creates the test object.
 2826|      2|  Test* const test = internal::HandleExceptionsInMethodIfSupported(
 2827|      2|      factory_, &internal::TestFactoryBase::CreateTest,
 2828|      2|      "the test fixture's constructor");
 2829|       |
 2830|       |  // Runs the test if the constructor didn't generate a fatal failure or invoke
 2831|       |  // GTEST_SKIP().
 2832|       |  // Note that the object will not be null
 2833|      2|  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
  ------------------
  |  Branch (2833:7): [True: 2, False: 0]
  |  Branch (2833:35): [True: 2, False: 0]
  ------------------
 2834|       |    // This doesn't throw as all user code that can throw are wrapped into
 2835|       |    // exception handling code.
 2836|      2|    test->Run();
 2837|      2|  }
 2838|       |
 2839|      2|  if (test != nullptr) {
  ------------------
  |  Branch (2839:7): [True: 0, False: 2]
  ------------------
 2840|       |    // Deletes the test object.
 2841|      0|    impl->os_stack_trace_getter()->UponLeavingGTest();
 2842|      0|    internal::HandleExceptionsInMethodIfSupported(
 2843|      0|        test, &Test::DeleteSelf_, "the test fixture's destructor");
 2844|      0|  }
 2845|       |
 2846|      2|  result_.set_elapsed_time(timer.Elapsed());
 2847|       |
 2848|       |  // Notifies the unit test event listener that a test has just finished.
 2849|      2|  repeater->OnTestEnd(*this);
 2850|       |
 2851|       |  // Tells UnitTest to stop associating assertion results to this
 2852|       |  // test.
 2853|      2|  impl->set_current_test_info(nullptr);
 2854|      2|}
_ZNK7testing9TestSuite17test_to_run_countEv:
 2911|      4|int TestSuite::test_to_run_count() const {
 2912|      4|  return CountIf(test_info_list_, ShouldRunTest);
 2913|      4|}
_ZNK7testing9TestSuite16total_test_countEv:
 2916|      2|int TestSuite::total_test_count() const {
 2917|      2|  return static_cast<int>(test_info_list_.size());
 2918|      2|}
_ZN7testing9TestSuiteC2EPKcS2_PFvvES4_:
 2932|      2|    : name_(a_name),
 2933|      2|      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
  ------------------
  |  Branch (2933:19): [True: 0, False: 2]
  ------------------
 2934|      2|      set_up_tc_(set_up_tc),
 2935|      2|      tear_down_tc_(tear_down_tc),
 2936|      2|      should_run_(false),
 2937|      2|      start_timestamp_(0),
 2938|      2|      elapsed_time_(0) {}
_ZN7testing9TestSuite18GetMutableTestInfoEi:
 2955|      2|TestInfo* TestSuite::GetMutableTestInfo(int i) {
 2956|      2|  const int index = GetElementOr(test_indices_, i, -1);
 2957|      2|  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
  ------------------
  |  Branch (2957:10): [True: 0, False: 2]
  ------------------
 2958|      2|}
_ZN7testing9TestSuite11AddTestInfoEPNS_8TestInfoE:
 2962|      2|void TestSuite::AddTestInfo(TestInfo* test_info) {
 2963|      2|  test_info_list_.push_back(test_info);
 2964|      2|  test_indices_.push_back(static_cast<int>(test_indices_.size()));
 2965|      2|}
_ZN7testing9TestSuite3RunEv:
 2968|      2|void TestSuite::Run() {
 2969|      2|  if (!should_run_) return;
  ------------------
  |  Branch (2969:7): [True: 0, False: 2]
  ------------------
 2970|       |
 2971|      2|  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
 2972|      2|  impl->set_current_test_suite(this);
 2973|       |
 2974|      2|  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
 2975|       |
 2976|       |  // Ensure our tests are in a deterministic order.
 2977|       |  //
 2978|       |  // We do this by sorting lexicographically on (file, line number), providing
 2979|       |  // an order matching what the user can see in the source code.
 2980|       |  //
 2981|       |  // In the common case the line number comparison shouldn't be necessary,
 2982|       |  // because the registrations made by the TEST macro are executed in order
 2983|       |  // within a translation unit. But this is not true of the manual registration
 2984|       |  // API, and in more exotic scenarios a single file may be part of multiple
 2985|       |  // translation units.
 2986|      2|  std::stable_sort(test_info_list_.begin(), test_info_list_.end(),
 2987|      2|                   [](const TestInfo* const a, const TestInfo* const b) {
 2988|      2|                     if (const int result = std::strcmp(a->file(), b->file())) {
 2989|      2|                       return result < 0;
 2990|      2|                     }
 2991|       |
 2992|      2|                     return a->line() < b->line();
 2993|      2|                   });
 2994|       |
 2995|       |  // Call both legacy and the new API
 2996|      2|  repeater->OnTestSuiteStart(*this);
 2997|       |//  Legacy API is deprecated but still available
 2998|      2|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 2999|      2|  repeater->OnTestCaseStart(*this);
 3000|      2|#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3001|       |
 3002|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 3003|      2|  internal::HandleExceptionsInMethodIfSupported(
 3004|      2|      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
 3005|       |
 3006|      2|  const bool skip_all =
 3007|      2|      ad_hoc_test_result().Failed() || ad_hoc_test_result().Skipped();
  ------------------
  |  Branch (3007:7): [True: 0, False: 2]
  |  Branch (3007:40): [True: 0, False: 2]
  ------------------
 3008|       |
 3009|      2|  start_timestamp_ = internal::GetTimeInMillis();
 3010|      2|  internal::Timer timer;
 3011|      4|  for (int i = 0; i < total_test_count(); i++) {
  ------------------
  |  Branch (3011:19): [True: 2, False: 2]
  ------------------
 3012|      2|    if (skip_all) {
  ------------------
  |  Branch (3012:9): [True: 0, False: 2]
  ------------------
 3013|      0|      GetMutableTestInfo(i)->Skip();
 3014|      2|    } else {
 3015|      2|      GetMutableTestInfo(i)->Run();
 3016|      2|    }
 3017|      2|    if (GTEST_FLAG_GET(fail_fast) &&
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3018|      0|        GetMutableTestInfo(i)->result()->Failed()) {
  ------------------
  |  Branch (3018:9): [True: 0, False: 0]
  ------------------
 3019|      0|      for (int j = i + 1; j < total_test_count(); j++) {
  ------------------
  |  Branch (3019:27): [True: 0, False: 0]
  ------------------
 3020|      0|        GetMutableTestInfo(j)->Skip();
 3021|      0|      }
 3022|      0|      break;
 3023|      0|    }
 3024|      2|  }
 3025|      2|  elapsed_time_ = timer.Elapsed();
 3026|       |
 3027|      2|  impl->os_stack_trace_getter()->UponLeavingGTest();
 3028|      2|  internal::HandleExceptionsInMethodIfSupported(
 3029|      2|      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
 3030|       |
 3031|       |  // Call both legacy and the new API
 3032|      2|  repeater->OnTestSuiteEnd(*this);
 3033|       |//  Legacy API is deprecated but still available
 3034|      2|#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3035|      2|  repeater->OnTestCaseEnd(*this);
 3036|      2|#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 3037|       |
 3038|      2|  impl->set_current_test_suite(nullptr);
 3039|      2|}
_ZN7testing9TestSuite11ClearResultEv:
 3072|      2|void TestSuite::ClearResult() {
 3073|      2|  ad_hoc_test_result_.Clear();
 3074|      2|  ForEach(test_info_list_, TestInfo::ClearTestResult);
 3075|      2|}
_ZN7testing8internal14ShouldUseColorEb:
 3238|      2|bool ShouldUseColor(bool stdout_is_tty) {
 3239|      2|  std::string c = GTEST_FLAG_GET(color);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 3240|      2|  const char* const gtest_color = c.c_str();
 3241|       |
 3242|      2|  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
  ------------------
  |  Branch (3242:7): [True: 2, False: 0]
  ------------------
 3243|       |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
 3244|       |    // On Windows the TERM variable is usually not set, but the
 3245|       |    // console there does support colors.
 3246|       |    return stdout_is_tty;
 3247|       |#else
 3248|       |    // On non-Windows platforms, we rely on the TERM variable.
 3249|      2|    const char* const term = posix::GetEnv("TERM");
 3250|      2|    const bool term_supports_color =
 3251|      2|        term != nullptr && (String::CStringEquals(term, "xterm") ||
  ------------------
  |  Branch (3251:9): [True: 0, False: 2]
  |  Branch (3251:29): [True: 0, False: 0]
  ------------------
 3252|      0|                            String::CStringEquals(term, "xterm-color") ||
  ------------------
  |  Branch (3252:29): [True: 0, False: 0]
  ------------------
 3253|      0|                            String::CStringEquals(term, "xterm-kitty") ||
  ------------------
  |  Branch (3253:29): [True: 0, False: 0]
  ------------------
 3254|      0|                            String::CStringEquals(term, "screen") ||
  ------------------
  |  Branch (3254:29): [True: 0, False: 0]
  ------------------
 3255|      0|                            String::CStringEquals(term, "tmux") ||
  ------------------
  |  Branch (3255:29): [True: 0, False: 0]
  ------------------
 3256|      0|                            String::CStringEquals(term, "rxvt-unicode") ||
  ------------------
  |  Branch (3256:29): [True: 0, False: 0]
  ------------------
 3257|      0|                            String::CStringEquals(term, "linux") ||
  ------------------
  |  Branch (3257:29): [True: 0, False: 0]
  ------------------
 3258|      0|                            String::CStringEquals(term, "cygwin") ||
  ------------------
  |  Branch (3258:29): [True: 0, False: 0]
  ------------------
 3259|      0|                            String::EndsWithCaseInsensitive(term, "-256color"));
  ------------------
  |  Branch (3259:29): [True: 0, False: 0]
  ------------------
 3260|      2|    return stdout_is_tty && term_supports_color;
  ------------------
  |  Branch (3260:12): [True: 0, False: 2]
  |  Branch (3260:29): [True: 0, False: 0]
  ------------------
 3261|      2|#endif  // GTEST_OS_WINDOWS
 3262|      2|  }
 3263|       |
 3264|      0|  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
  ------------------
  |  Branch (3264:10): [True: 0, False: 0]
  ------------------
 3265|      0|         String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
  ------------------
  |  Branch (3265:10): [True: 0, False: 0]
  ------------------
 3266|      0|         String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
  ------------------
  |  Branch (3266:10): [True: 0, False: 0]
  ------------------
 3267|      0|         String::CStringEquals(gtest_color, "1");
  ------------------
  |  Branch (3267:10): [True: 0, False: 0]
  ------------------
 3268|       |  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
 3269|       |  // value is neither one of these nor "auto", we treat it as "no" to
 3270|       |  // be conservative.
 3271|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter20OnTestIterationStartERKNS_8UnitTestEi:
 3394|      2|    const UnitTest& unit_test, int iteration) {
 3395|      2|  if (GTEST_FLAG_GET(repeat) != 1)
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (3395:7): [True: 0, False: 2]
  ------------------
 3396|      0|    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
 3397|       |
 3398|      2|  std::string f = GTEST_FLAG_GET(filter);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 3399|      2|  const char* const filter = f.c_str();
 3400|       |
 3401|       |  // Prints the filter if it's not *.  This reminds the user that some
 3402|       |  // tests may be skipped.
 3403|      2|  if (!String::CStringEquals(filter, kUniversalFilter)) {
  ------------------
  |  Branch (3403:7): [True: 2, False: 0]
  ------------------
 3404|      2|    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
  ------------------
  |  |  334|      2|#define GTEST_NAME_ "Google Test"
  ------------------
 3405|      2|                  filter);
 3406|      2|  }
 3407|       |
 3408|      2|  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
  ------------------
  |  Branch (3408:7): [True: 0, False: 2]
  ------------------
 3409|      0|    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
 3410|      0|    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
 3411|      0|                  static_cast<int>(shard_index) + 1,
 3412|      0|                  internal::posix::GetEnv(kTestTotalShards));
 3413|      0|  }
 3414|       |
 3415|      2|  if (GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 3416|      0|    ColoredPrintf(GTestColor::kYellow,
 3417|      0|                  "Note: Randomizing tests' orders with a seed of %d .\n",
 3418|      0|                  unit_test.random_seed());
 3419|      0|  }
 3420|       |
 3421|      2|  ColoredPrintf(GTestColor::kGreen, "[==========] ");
 3422|      2|  printf("Running %s from %s.\n",
 3423|      2|         FormatTestCount(unit_test.test_to_run_count()).c_str(),
 3424|      2|         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
 3425|       |  fflush(stdout);
 3426|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter24OnEnvironmentsSetUpStartERKNS_8UnitTestE:
 3429|      2|    const UnitTest& /*unit_test*/) {
 3430|      2|  ColoredPrintf(GTestColor::kGreen, "[----------] ");
 3431|      2|  printf("Global test environment set-up.\n");
 3432|       |  fflush(stdout);
 3433|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter15OnTestCaseStartERKNS_9TestSuiteE:
 3436|      2|void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
 3437|      2|  const std::string counts =
 3438|      2|      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
 3439|      2|  ColoredPrintf(GTestColor::kGreen, "[----------] ");
 3440|      2|  printf("%s from %s", counts.c_str(), test_case.name());
 3441|      2|  if (test_case.type_param() == nullptr) {
  ------------------
  |  Branch (3441:7): [True: 2, False: 0]
  ------------------
 3442|      2|    printf("\n");
 3443|      2|  } else {
 3444|      0|    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
 3445|      0|  }
 3446|       |  fflush(stdout);
 3447|      2|}
_ZN7testing8internal27PrettyUnitTestResultPrinter11OnTestStartERKNS_8TestInfoE:
 3464|      2|void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
 3465|      2|  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
 3466|      2|  PrintTestName(test_info.test_suite_name(), test_info.name());
 3467|      2|  printf("\n");
 3468|       |  fflush(stdout);
 3469|      2|}
_ZN7testing8internal17TestEventRepeater6AppendEPNS_17TestEventListenerE:
 3815|      6|void TestEventRepeater::Append(TestEventListener* listener) {
 3816|      6|  listeners_.push_back(listener);
 3817|      6|}
_ZN7testing8internal17TestEventRepeater7ReleaseEPNS_17TestEventListenerE:
 3819|      2|TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
 3820|      2|  for (size_t i = 0; i < listeners_.size(); ++i) {
  ------------------
  |  Branch (3820:22): [True: 0, False: 2]
  ------------------
 3821|      0|    if (listeners_[i] == listener) {
  ------------------
  |  Branch (3821:9): [True: 0, False: 0]
  ------------------
 3822|      0|      listeners_.erase(listeners_.begin() + static_cast<int>(i));
 3823|      0|      return listener;
 3824|      0|    }
 3825|      0|  }
 3826|       |
 3827|      2|  return nullptr;
 3828|      2|}
_ZN7testing8internal17TestEventRepeater18OnTestProgramStartERKNS_8UnitTestE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater24OnEnvironmentsSetUpStartERKNS_8UnitTestE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater15OnTestCaseStartERKNS_9TestSuiteE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater16OnTestSuiteStartERKNS_9TestSuiteE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater11OnTestStartERKNS_8TestInfoE:
 3833|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3834|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3834:9): [True: 2, False: 0]
  ------------------
 3835|      8|      for (size_t i = 0; i < listeners_.size(); i++) {  \
  ------------------
  |  Branch (3835:26): [True: 6, False: 2]
  ------------------
 3836|      6|        listeners_[i]->Name(parameter);                 \
 3837|      6|      }                                                 \
 3838|      2|    }                                                   \
 3839|      2|  }
_ZN7testing8internal17TestEventRepeater22OnEnvironmentsSetUpEndERKNS_8UnitTestE:
 3843|      2|  void TestEventRepeater::Name(const Type& parameter) { \
 3844|      2|    if (forwarding_enabled_) {                          \
  ------------------
  |  Branch (3844:9): [True: 2, False: 0]
  ------------------
 3845|      8|      for (size_t i = listeners_.size(); i != 0; i--) { \
  ------------------
  |  Branch (3845:42): [True: 6, False: 2]
  ------------------
 3846|      6|        listeners_[i - 1]->Name(parameter);             \
 3847|      6|      }                                                 \
 3848|      2|    }                                                   \
 3849|      2|  }
_ZN7testing8internal17TestEventRepeater20OnTestIterationStartERKNS_8UnitTestEi:
 3876|      2|                                             int iteration) {
 3877|      2|  if (forwarding_enabled_) {
  ------------------
  |  Branch (3877:7): [True: 2, False: 0]
  ------------------
 3878|      8|    for (size_t i = 0; i < listeners_.size(); i++) {
  ------------------
  |  Branch (3878:24): [True: 6, False: 2]
  ------------------
 3879|      6|      listeners_[i]->OnTestIterationStart(unit_test, iteration);
 3880|      6|    }
 3881|      2|  }
 3882|      2|}
_ZN7testing8internal18OsStackTraceGetter16UponLeavingGTestEv:
 5021|      8|void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
 5022|       |#ifdef GTEST_HAS_ABSL
 5023|       |  void* caller_frame = nullptr;
 5024|       |  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
 5025|       |    caller_frame = nullptr;
 5026|       |  }
 5027|       |
 5028|       |  MutexLock lock(&mutex_);
 5029|       |  caller_frame_ = caller_frame;
 5030|       |#endif  // GTEST_HAS_ABSL
 5031|      8|}
_ZN7testing18TestEventListenersC2Ev:
 5078|      2|    : repeater_(new internal::TestEventRepeater()),
 5079|      2|      default_result_printer_(nullptr),
 5080|      2|      default_xml_generator_(nullptr) {}
_ZN7testing18TestEventListeners6AppendEPNS_17TestEventListenerE:
 5088|      6|void TestEventListeners::Append(TestEventListener* listener) {
 5089|      6|  repeater_->Append(listener);
 5090|      6|}
_ZN7testing18TestEventListeners7ReleaseEPNS_17TestEventListenerE:
 5095|      2|TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
 5096|      2|  if (listener == default_result_printer_)
  ------------------
  |  Branch (5096:7): [True: 2, False: 0]
  ------------------
 5097|      2|    default_result_printer_ = nullptr;
 5098|      0|  else if (listener == default_xml_generator_)
  ------------------
  |  Branch (5098:12): [True: 0, False: 0]
  ------------------
 5099|      0|    default_xml_generator_ = nullptr;
 5100|      2|  return repeater_->Release(listener);
 5101|      2|}
_ZN7testing18TestEventListeners8repeaterEv:
 5105|      6|TestEventListener* TestEventListeners::repeater() { return repeater_; }
_ZN7testing18TestEventListeners23SetDefaultResultPrinterEPNS_17TestEventListenerE:
 5112|      2|void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
 5113|      2|  if (default_result_printer_ != listener) {
  ------------------
  |  Branch (5113:7): [True: 2, False: 0]
  ------------------
 5114|       |    // It is an error to pass this method a listener that is already in the
 5115|       |    // list.
 5116|      2|    delete Release(default_result_printer_);
 5117|      2|    default_result_printer_ = listener;
 5118|      2|    if (listener != nullptr) Append(listener);
  ------------------
  |  Branch (5118:9): [True: 2, False: 0]
  ------------------
 5119|      2|  }
 5120|      2|}
_ZN7testing8UnitTest11GetInstanceEv:
 5156|     46|UnitTest* UnitTest::GetInstance() {
 5157|       |  // CodeGear C++Builder insists on a public destructor for the
 5158|       |  // default implementation.  Use this implementation to keep good OO
 5159|       |  // design with private destructor.
 5160|       |
 5161|       |#if defined(__BORLANDC__)
 5162|       |  static UnitTest* const instance = new UnitTest;
 5163|       |  return instance;
 5164|       |#else
 5165|     46|  static UnitTest instance;
 5166|     46|  return &instance;
 5167|     46|#endif  // defined(__BORLANDC__)
 5168|     46|}
_ZNK7testing8UnitTest23test_suite_to_run_countEv:
 5187|      2|int UnitTest::test_suite_to_run_count() const {
 5188|      2|  return impl()->test_suite_to_run_count();
 5189|      2|}
_ZNK7testing8UnitTest17test_to_run_countEv:
 5239|      2|int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
_ZN7testing8UnitTest9listenersEv:
 5287|      8|TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }
_ZN7testing8UnitTest3RunEv:
 5399|      2|int UnitTest::Run() {
 5400|      2|#ifdef GTEST_HAS_DEATH_TEST
 5401|      2|  const bool in_death_test_child_process =
 5402|      2|      GTEST_FLAG_GET(internal_run_death_test).length() > 0;
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5403|       |
 5404|       |  // Google Test implements this protocol for catching that a test
 5405|       |  // program exits before returning control to Google Test:
 5406|       |  //
 5407|       |  //   1. Upon start, Google Test creates a file whose absolute path
 5408|       |  //      is specified by the environment variable
 5409|       |  //      TEST_PREMATURE_EXIT_FILE.
 5410|       |  //   2. When Google Test has finished its work, it deletes the file.
 5411|       |  //
 5412|       |  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
 5413|       |  // running a Google-Test-based test program and check the existence
 5414|       |  // of the file at the end of the test execution to see if it has
 5415|       |  // exited prematurely.
 5416|       |
 5417|       |  // If we are in the child process of a death test, don't
 5418|       |  // create/delete the premature exit file, as doing so is unnecessary
 5419|       |  // and will confuse the parent process.  Otherwise, create/delete
 5420|       |  // the file upon entering/leaving this function.  If the program
 5421|       |  // somehow exits before this function has a chance to return, the
 5422|       |  // premature-exit file will be left undeleted, causing a test runner
 5423|       |  // that understands the premature-exit-file protocol to report the
 5424|       |  // test as having failed.
 5425|      2|  const internal::ScopedPrematureExitFile premature_exit_file(
 5426|      2|      in_death_test_child_process
  ------------------
  |  Branch (5426:7): [True: 0, False: 2]
  ------------------
 5427|      2|          ? nullptr
 5428|      2|          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
 5429|       |#else
 5430|       |  const bool in_death_test_child_process = false;
 5431|       |#endif  // GTEST_HAS_DEATH_TEST
 5432|       |
 5433|       |  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
 5434|       |  // used for the duration of the program.
 5435|      2|  impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5436|       |
 5437|       |#ifdef GTEST_OS_WINDOWS
 5438|       |  // Either the user wants Google Test to catch exceptions thrown by the
 5439|       |  // tests or this is executing in the context of death test child
 5440|       |  // process. In either case the user does not want to see pop-up dialogs
 5441|       |  // about crashes - they are expected.
 5442|       |  if (impl()->catch_exceptions() || in_death_test_child_process) {
 5443|       |#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
 5444|       |    !defined(GTEST_OS_WINDOWS_RT)
 5445|       |    // SetErrorMode doesn't exist on CE.
 5446|       |    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
 5447|       |                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
 5448|       |#endif  // !GTEST_OS_WINDOWS_MOBILE
 5449|       |
 5450|       |#if (defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)) && \
 5451|       |    !defined(GTEST_OS_WINDOWS_MOBILE)
 5452|       |    // Death test children can be terminated with _abort().  On Windows,
 5453|       |    // _abort() can show a dialog with a warning message.  This forces the
 5454|       |    // abort message to go to stderr instead.
 5455|       |    _set_error_mode(_OUT_TO_STDERR);
 5456|       |#endif
 5457|       |
 5458|       |#if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE)
 5459|       |    // In the debug version, Visual Studio pops up a separate dialog
 5460|       |    // offering a choice to debug the aborted program. We need to suppress
 5461|       |    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
 5462|       |    // executed. Google Test will notify the user of any unexpected
 5463|       |    // failure via stderr.
 5464|       |    if (!GTEST_FLAG_GET(break_on_failure))
 5465|       |      _set_abort_behavior(
 5466|       |          0x0,                                    // Clear the following flags:
 5467|       |          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
 5468|       |
 5469|       |    // In debug mode, the Windows CRT can crash with an assertion over invalid
 5470|       |    // input (e.g. passing an invalid file descriptor).  The default handling
 5471|       |    // for these assertions is to pop up a dialog and wait for user input.
 5472|       |    // Instead ask the CRT to dump such assertions to stderr non-interactively.
 5473|       |    if (!IsDebuggerPresent()) {
 5474|       |      (void)_CrtSetReportMode(_CRT_ASSERT,
 5475|       |                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
 5476|       |      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 5477|       |    }
 5478|       |#endif
 5479|       |  }
 5480|       |#else
 5481|      2|  (void)in_death_test_child_process;  // Needed inside the #if block above
 5482|      2|#endif  // GTEST_OS_WINDOWS
 5483|       |
 5484|      2|  return internal::HandleExceptionsInMethodIfSupported(
  ------------------
  |  Branch (5484:10): [True: 0, False: 2]
  ------------------
 5485|      2|             impl(), &internal::UnitTestImpl::RunAllTests,
 5486|      2|             "auxiliary test code (environments or event listeners)")
 5487|      2|             ? 0
 5488|      2|             : 1;
 5489|      2|}
_ZN7testing8UnitTestC2Ev:
 5535|      2|UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); }
_ZN7testing8internal12UnitTestImplC2EPNS_8UnitTestE:
 5557|      2|    : parent_(parent),
 5558|       |      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
 5559|      2|          default_global_test_part_result_reporter_(this),
 5560|      2|      default_per_thread_test_part_result_reporter_(this),
 5561|       |      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_reporter_(
 5562|      2|          &default_global_test_part_result_reporter_),
 5563|      2|      per_thread_test_part_result_reporter_(
 5564|      2|          &default_per_thread_test_part_result_reporter_),
 5565|      2|      parameterized_test_registry_(),
 5566|      2|      parameterized_tests_registered_(false),
 5567|      2|      last_death_test_suite_(-1),
 5568|      2|      current_test_suite_(nullptr),
 5569|      2|      current_test_info_(nullptr),
 5570|      2|      ad_hoc_test_result_(),
 5571|      2|      os_stack_trace_getter_(nullptr),
 5572|      2|      post_flag_parse_init_performed_(false),
 5573|      2|      random_seed_(0),  // Will be overridden by the flag before first use.
 5574|      2|      random_(0),       // Will be reseeded before first use.
 5575|      2|      start_timestamp_(0),
 5576|      2|      elapsed_time_(0),
 5577|       |#ifdef GTEST_HAS_DEATH_TEST
 5578|      2|      death_test_factory_(new DefaultDeathTestFactory),
 5579|       |#endif
 5580|       |      // Will be overridden by the flag before first use.
 5581|      2|      catch_exceptions_(false) {
 5582|      2|  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
 5583|      2|}
_ZN7testing8internal12UnitTestImpl32SuppressTestEventsIfInSubprocessEv:
 5620|      2|void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
 5621|      2|  if (internal_run_death_test_flag_ != nullptr)
  ------------------
  |  Branch (5621:7): [True: 0, False: 2]
  ------------------
 5622|      0|    listeners()->SuppressEventForwarding(true);
 5623|      2|}
_ZN7testing8internal12UnitTestImpl18ConfigureXmlOutputEv:
 5628|      2|void UnitTestImpl::ConfigureXmlOutput() {
 5629|      2|  const std::string& output_format = UnitTestOptions::GetOutputFormat();
 5630|      2|#if GTEST_HAS_FILE_SYSTEM
 5631|      2|  if (output_format == "xml") {
  ------------------
  |  Branch (5631:7): [True: 0, False: 2]
  ------------------
 5632|      0|    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
 5633|      0|        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
 5634|      2|  } else if (output_format == "json") {
  ------------------
  |  Branch (5634:14): [True: 0, False: 2]
  ------------------
 5635|      0|    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
 5636|      0|        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
 5637|      2|  } else if (!output_format.empty()) {
  ------------------
  |  Branch (5637:14): [True: 0, False: 2]
  ------------------
 5638|      0|    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
  ------------------
  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  | 1056|      0|      .GetStream()
  ------------------
 5639|      0|                        << output_format << "\" ignored.";
 5640|      0|  }
 5641|       |#else
 5642|       |  if (!output_format.empty()) {
 5643|       |    GTEST_LOG_(ERROR) << "ERROR: alternative output formats require "
 5644|       |                      << "GTEST_HAS_FILE_SYSTEM to be enabled";
 5645|       |  }
 5646|       |#endif  // GTEST_HAS_FILE_SYSTEM
 5647|      2|}
_ZN7testing8internal12UnitTestImpl24ConfigureStreamingOutputEv:
 5652|      2|void UnitTestImpl::ConfigureStreamingOutput() {
 5653|      2|  const std::string& target = GTEST_FLAG_GET(stream_result_to);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5654|      2|  if (!target.empty()) {
  ------------------
  |  Branch (5654:7): [True: 0, False: 2]
  ------------------
 5655|      0|    const size_t pos = target.find(':');
 5656|      0|    if (pos != std::string::npos) {
  ------------------
  |  Branch (5656:9): [True: 0, False: 0]
  ------------------
 5657|      0|      listeners()->Append(
 5658|      0|          new StreamingListener(target.substr(0, pos), target.substr(pos + 1)));
 5659|      0|    } else {
 5660|      0|      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
  ------------------
  |  | 1054|      0|  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
  |  | 1055|      0|                                __FILE__, __LINE__)                    \
  |  | 1056|      0|      .GetStream()
  ------------------
 5661|      0|                          << "\" ignored.";
 5662|      0|    }
 5663|      0|  }
 5664|      2|}
_ZN7testing8internal12UnitTestImpl19PostFlagParsingInitEv:
 5672|      4|void UnitTestImpl::PostFlagParsingInit() {
 5673|       |  // Ensures that this function does not execute more than once.
 5674|      4|  if (!post_flag_parse_init_performed_) {
  ------------------
  |  Branch (5674:7): [True: 2, False: 2]
  ------------------
 5675|      2|    post_flag_parse_init_performed_ = true;
 5676|       |
 5677|       |#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 5678|       |    // Register to send notifications about key process state changes.
 5679|       |    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
 5680|       |#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
 5681|       |
 5682|      2|#ifdef GTEST_HAS_DEATH_TEST
 5683|      2|    InitDeathTestSubprocessControlInfo();
 5684|      2|    SuppressTestEventsIfInSubprocess();
 5685|      2|#endif  // GTEST_HAS_DEATH_TEST
 5686|       |
 5687|       |    // Registers parameterized tests. This makes parameterized tests
 5688|       |    // available to the UnitTest reflection API without running
 5689|       |    // RUN_ALL_TESTS.
 5690|      2|    RegisterParameterizedTests();
 5691|       |
 5692|       |    // Configures listeners for XML output. This makes it possible for users
 5693|       |    // to shut down the default XML output before invoking RUN_ALL_TESTS.
 5694|      2|    ConfigureXmlOutput();
 5695|       |
 5696|      2|    if (GTEST_FLAG_GET(brief)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5697|      0|      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
 5698|      0|    }
 5699|       |
 5700|      2|#if GTEST_CAN_STREAM_RESULTS_
 5701|       |    // Configures listeners for streaming test results to the specified server.
 5702|      2|    ConfigureStreamingOutput();
 5703|      2|#endif  // GTEST_CAN_STREAM_RESULTS_
 5704|       |
 5705|       |#ifdef GTEST_HAS_ABSL
 5706|       |    if (GTEST_FLAG_GET(install_failure_signal_handler)) {
 5707|       |      absl::FailureSignalHandlerOptions options;
 5708|       |      absl::InstallFailureSignalHandler(options);
 5709|       |    }
 5710|       |#endif  // GTEST_HAS_ABSL
 5711|      2|  }
 5712|      4|}
_ZN7testing8internal12UnitTestImpl12GetTestSuiteEPKcS3_PFvvES5_:
 5752|      2|    internal::TearDownTestSuiteFunc tear_down_tc) {
 5753|       |  // Can we find a TestSuite with the given name?
 5754|      2|  const auto test_suite =
 5755|      2|      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
 5756|      2|                   TestSuiteNameIs(test_suite_name));
 5757|       |
 5758|      2|  if (test_suite != test_suites_.rend()) return *test_suite;
  ------------------
  |  Branch (5758:7): [True: 0, False: 2]
  ------------------
 5759|       |
 5760|       |  // No.  Let's create one.
 5761|      2|  auto* const new_test_suite =
 5762|      2|      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
 5763|       |
 5764|      2|  const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);
 5765|       |  // Is this a death test suite?
 5766|      2|  if (death_test_suite_filter.MatchesName(test_suite_name)) {
  ------------------
  |  Branch (5766:7): [True: 0, False: 2]
  ------------------
 5767|       |    // Yes.  Inserts the test suite after the last death test suite
 5768|       |    // defined so far.  This only works when the test suites haven't
 5769|       |    // been shuffled.  Otherwise we may end up running a death test
 5770|       |    // after a non-death test.
 5771|      0|    ++last_death_test_suite_;
 5772|      0|    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
 5773|      0|                        new_test_suite);
 5774|      2|  } else {
 5775|       |    // No.  Appends to the end of the list.
 5776|      2|    test_suites_.push_back(new_test_suite);
 5777|      2|  }
 5778|       |
 5779|      2|  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
 5780|      2|  return new_test_suite;
 5781|      2|}
_ZN7testing8internal12UnitTestImpl11RunAllTestsEv:
 5797|      2|bool UnitTestImpl::RunAllTests() {
 5798|       |  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
 5799|       |  // called.
 5800|      2|  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
 5801|       |
 5802|       |  // Do not run any test if the --help flag was specified.
 5803|      2|  if (g_help_flag) return true;
  ------------------
  |  Branch (5803:7): [True: 0, False: 2]
  ------------------
 5804|       |
 5805|       |  // Repeats the call to the post-flag parsing initialization in case the
 5806|       |  // user didn't call InitGoogleTest.
 5807|      2|  PostFlagParsingInit();
 5808|       |
 5809|      2|#if GTEST_HAS_FILE_SYSTEM
 5810|       |  // Even if sharding is not on, test runners may want to use the
 5811|       |  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
 5812|       |  // protocol.
 5813|      2|  internal::WriteToShardStatusFileIfNeeded();
 5814|      2|#endif  // GTEST_HAS_FILE_SYSTEM
 5815|       |
 5816|       |  // True if and only if we are in a subprocess for running a thread-safe-style
 5817|       |  // death test.
 5818|      2|  bool in_subprocess_for_death_test = false;
 5819|       |
 5820|      2|#ifdef GTEST_HAS_DEATH_TEST
 5821|      2|  in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr);
 5822|       |#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 5823|       |  if (in_subprocess_for_death_test) {
 5824|       |    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
 5825|       |  }
 5826|       |#endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
 5827|      2|#endif  // GTEST_HAS_DEATH_TEST
 5828|       |
 5829|      2|  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
 5830|      2|                                        in_subprocess_for_death_test);
 5831|       |
 5832|       |  // Compares the full test names with the filter to decide which
 5833|       |  // tests to run.
 5834|      2|  const bool has_tests_to_run =
 5835|      2|      FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (5835:19): [True: 0, False: 2]
  ------------------
 5836|      2|                               : IGNORE_SHARDING_PROTOCOL) > 0;
 5837|       |
 5838|       |  // Lists the tests and exits if the --gtest_list_tests flag was specified.
 5839|      2|  if (GTEST_FLAG_GET(list_tests)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5840|       |    // This must be called *after* FilterTests() has been called.
 5841|      0|    ListTestsMatchingFilter();
 5842|      0|    return true;
 5843|      0|  }
 5844|       |
 5845|      2|  random_seed_ = GetRandomSeedFromFlag(GTEST_FLAG_GET(random_seed));
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 5846|       |
 5847|       |  // True if and only if at least one test has failed.
 5848|      2|  bool failed = false;
 5849|       |
 5850|      2|  TestEventListener* repeater = listeners()->repeater();
 5851|       |
 5852|      2|  start_timestamp_ = GetTimeInMillis();
 5853|      2|  repeater->OnTestProgramStart(*parent_);
 5854|       |
 5855|       |  // How many times to repeat the tests?  We don't want to repeat them
 5856|       |  // when we are inside the subprocess of a death test.
 5857|      2|  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG_GET(repeat);
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
  |  Branch (5857:22): [True: 0, False: 2]
  ------------------
 5858|       |
 5859|       |  // Repeats forever if the repeat count is negative.
 5860|      2|  const bool gtest_repeat_forever = repeat < 0;
 5861|       |
 5862|       |  // Should test environments be set up and torn down for each repeat, or only
 5863|       |  // set up on the first and torn down on the last iteration? If there is no
 5864|       |  // "last" iteration because the tests will repeat forever, always recreate the
 5865|       |  // environments to avoid leaks in case one of the environments is using
 5866|       |  // resources that are external to this process. Without this check there would
 5867|       |  // be no way to clean up those external resources automatically.
 5868|      2|  const bool recreate_environments_when_repeating =
 5869|      2|      GTEST_FLAG_GET(recreate_environments_when_repeating) ||
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5870|      2|      gtest_repeat_forever;
  ------------------
  |  Branch (5870:7): [True: 0, False: 2]
  ------------------
 5871|       |
 5872|      4|  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
  ------------------
  |  Branch (5872:19): [True: 2, False: 2]
  |  Branch (5872:43): [True: 2, False: 0]
  ------------------
 5873|       |    // We want to preserve failures generated by ad-hoc test
 5874|       |    // assertions executed before RUN_ALL_TESTS().
 5875|      2|    ClearNonAdHocTestResult();
 5876|       |
 5877|      2|    Timer timer;
 5878|       |
 5879|       |    // Shuffles test suites and tests if requested.
 5880|      2|    if (has_tests_to_run && GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (5880:9): [True: 2, False: 0]
  ------------------
 5881|      0|      random()->Reseed(static_cast<uint32_t>(random_seed_));
 5882|       |      // This should be done before calling OnTestIterationStart(),
 5883|       |      // such that a test event listener can see the actual test order
 5884|       |      // in the event.
 5885|      0|      ShuffleTests();
 5886|      0|    }
 5887|       |
 5888|       |    // Tells the unit test event listeners that the tests are about to start.
 5889|      2|    repeater->OnTestIterationStart(*parent_, i);
 5890|       |
 5891|       |    // Runs each test suite if there is at least one test to run.
 5892|      2|    if (has_tests_to_run) {
  ------------------
  |  Branch (5892:9): [True: 2, False: 0]
  ------------------
 5893|       |      // Sets up all environments beforehand. If test environments aren't
 5894|       |      // recreated for each iteration, only do so on the first iteration.
 5895|      2|      if (i == 0 || recreate_environments_when_repeating) {
  ------------------
  |  Branch (5895:11): [True: 2, False: 0]
  |  Branch (5895:21): [True: 0, False: 0]
  ------------------
 5896|      2|        repeater->OnEnvironmentsSetUpStart(*parent_);
 5897|      2|        ForEach(environments_, SetUpEnvironment);
 5898|      2|        repeater->OnEnvironmentsSetUpEnd(*parent_);
 5899|      2|      }
 5900|       |
 5901|       |      // Runs the tests only if there was no fatal failure or skip triggered
 5902|       |      // during global set-up.
 5903|      2|      if (Test::IsSkipped()) {
  ------------------
  |  Branch (5903:11): [True: 0, False: 2]
  ------------------
 5904|       |        // Emit diagnostics when global set-up calls skip, as it will not be
 5905|       |        // emitted by default.
 5906|      0|        TestResult& test_result =
 5907|      0|            *internal::GetUnitTestImpl()->current_test_result();
 5908|      0|        for (int j = 0; j < test_result.total_part_count(); ++j) {
  ------------------
  |  Branch (5908:25): [True: 0, False: 0]
  ------------------
 5909|      0|          const TestPartResult& test_part_result =
 5910|      0|              test_result.GetTestPartResult(j);
 5911|      0|          if (test_part_result.type() == TestPartResult::kSkip) {
  ------------------
  |  Branch (5911:15): [True: 0, False: 0]
  ------------------
 5912|      0|            const std::string& result = test_part_result.message();
 5913|      0|            printf("%s\n", result.c_str());
 5914|      0|          }
 5915|      0|        }
 5916|      0|        fflush(stdout);
 5917|      2|      } else if (!Test::HasFatalFailure()) {
  ------------------
  |  Branch (5917:18): [True: 2, False: 0]
  ------------------
 5918|      4|        for (int test_index = 0; test_index < total_test_suite_count();
  ------------------
  |  Branch (5918:34): [True: 2, False: 2]
  ------------------
 5919|      2|             test_index++) {
 5920|      2|          GetMutableSuiteCase(test_index)->Run();
 5921|      2|          if (GTEST_FLAG_GET(fail_fast) &&
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5922|      0|              GetMutableSuiteCase(test_index)->Failed()) {
  ------------------
  |  Branch (5922:15): [True: 0, False: 0]
  ------------------
 5923|      0|            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
  ------------------
  |  Branch (5923:42): [True: 0, False: 0]
  ------------------
 5924|      0|              GetMutableSuiteCase(j)->Skip();
 5925|      0|            }
 5926|      0|            break;
 5927|      0|          }
 5928|      2|        }
 5929|      2|      } else if (Test::HasFatalFailure()) {
  ------------------
  |  Branch (5929:18): [True: 0, False: 0]
  ------------------
 5930|       |        // If there was a fatal failure during the global setup then we know we
 5931|       |        // aren't going to run any tests. Explicitly mark all of the tests as
 5932|       |        // skipped to make this obvious in the output.
 5933|      0|        for (int test_index = 0; test_index < total_test_suite_count();
  ------------------
  |  Branch (5933:34): [True: 0, False: 0]
  ------------------
 5934|      0|             test_index++) {
 5935|      0|          GetMutableSuiteCase(test_index)->Skip();
 5936|      0|        }
 5937|      0|      }
 5938|       |
 5939|       |      // Tears down all environments in reverse order afterwards. If test
 5940|       |      // environments aren't recreated for each iteration, only do so on the
 5941|       |      // last iteration.
 5942|      2|      if (i == repeat - 1 || recreate_environments_when_repeating) {
  ------------------
  |  Branch (5942:11): [True: 2, False: 0]
  |  Branch (5942:30): [True: 0, False: 0]
  ------------------
 5943|      0|        repeater->OnEnvironmentsTearDownStart(*parent_);
 5944|      0|        std::for_each(environments_.rbegin(), environments_.rend(),
 5945|      0|                      TearDownEnvironment);
 5946|      0|        repeater->OnEnvironmentsTearDownEnd(*parent_);
 5947|      0|      }
 5948|      2|    }
 5949|       |
 5950|      2|    elapsed_time_ = timer.Elapsed();
 5951|       |
 5952|       |    // Tells the unit test event listener that the tests have just finished.
 5953|      2|    repeater->OnTestIterationEnd(*parent_, i);
 5954|       |
 5955|       |    // Gets the result and clears it.
 5956|      2|    if (!Passed()) {
  ------------------
  |  Branch (5956:9): [True: 0, False: 2]
  ------------------
 5957|      0|      failed = true;
 5958|      0|    }
 5959|       |
 5960|       |    // Restores the original test order after the iteration.  This
 5961|       |    // allows the user to quickly repro a failure that happens in the
 5962|       |    // N-th iteration without repeating the first (N - 1) iterations.
 5963|       |    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
 5964|       |    // case the user somehow changes the value of the flag somewhere
 5965|       |    // (it's always safe to unshuffle the tests).
 5966|      2|    UnshuffleTests();
 5967|       |
 5968|      2|    if (GTEST_FLAG_GET(shuffle)) {
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 5969|       |      // Picks a new random seed for each iteration.
 5970|      0|      random_seed_ = GetNextRandomSeed(random_seed_);
 5971|      0|    }
 5972|      2|  }
 5973|       |
 5974|      2|  repeater->OnTestProgramEnd(*parent_);
 5975|       |
 5976|      2|  if (!gtest_is_initialized_before_run_all_tests) {
  ------------------
  |  Branch (5976:7): [True: 0, False: 2]
  ------------------
 5977|      0|    ColoredPrintf(
 5978|      0|        GTestColor::kRed,
 5979|      0|        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
 5980|      0|        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
 5981|      0|        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
 5982|      0|        " will start to enforce the valid usage. "
 5983|      0|        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
 5984|      0|  }
 5985|       |
 5986|      2|  return !failed;
 5987|      2|}
_ZN7testing8internal30WriteToShardStatusFileIfNeededEv:
 5994|      2|void WriteToShardStatusFileIfNeeded() {
 5995|      2|  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
 5996|      2|  if (test_shard_file != nullptr) {
  ------------------
  |  Branch (5996:7): [True: 0, False: 2]
  ------------------
 5997|      0|    FILE* const file = posix::FOpen(test_shard_file, "w");
 5998|      0|    if (file == nullptr) {
  ------------------
  |  Branch (5998:9): [True: 0, False: 0]
  ------------------
 5999|      0|      ColoredPrintf(GTestColor::kRed,
 6000|      0|                    "Could not write to the test shard status file \"%s\" "
 6001|      0|                    "specified by the %s environment variable.\n",
 6002|      0|                    test_shard_file, kTestShardStatusFile);
 6003|      0|      fflush(stdout);
 6004|      0|      exit(EXIT_FAILURE);
 6005|      0|    }
 6006|      0|    fclose(file);
 6007|      0|  }
 6008|      2|}
_ZN7testing8internal11ShouldShardEPKcS2_b:
 6018|      4|                 bool in_subprocess_for_death_test) {
 6019|      4|  if (in_subprocess_for_death_test) {
  ------------------
  |  Branch (6019:7): [True: 0, False: 4]
  ------------------
 6020|      0|    return false;
 6021|      0|  }
 6022|       |
 6023|      4|  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
 6024|      4|  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
 6025|       |
 6026|      4|  if (total_shards == -1 && shard_index == -1) {
  ------------------
  |  Branch (6026:7): [True: 4, False: 0]
  |  Branch (6026:29): [True: 4, False: 0]
  ------------------
 6027|      4|    return false;
 6028|      4|  } else if (total_shards == -1 && shard_index != -1) {
  ------------------
  |  Branch (6028:14): [True: 0, False: 0]
  |  Branch (6028:36): [True: 0, False: 0]
  ------------------
 6029|      0|    const Message msg = Message() << "Invalid environment variables: you have "
 6030|      0|                                  << kTestShardIndex << " = " << shard_index
 6031|      0|                                  << ", but have left " << kTestTotalShards
 6032|      0|                                  << " unset.\n";
 6033|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6034|      0|    fflush(stdout);
 6035|      0|    exit(EXIT_FAILURE);
 6036|      0|  } else if (total_shards != -1 && shard_index == -1) {
  ------------------
  |  Branch (6036:14): [True: 0, False: 0]
  |  Branch (6036:36): [True: 0, False: 0]
  ------------------
 6037|      0|    const Message msg = Message()
 6038|      0|                        << "Invalid environment variables: you have "
 6039|      0|                        << kTestTotalShards << " = " << total_shards
 6040|      0|                        << ", but have left " << kTestShardIndex << " unset.\n";
 6041|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6042|      0|    fflush(stdout);
 6043|      0|    exit(EXIT_FAILURE);
 6044|      0|  } else if (shard_index < 0 || shard_index >= total_shards) {
  ------------------
  |  Branch (6044:14): [True: 0, False: 0]
  |  Branch (6044:33): [True: 0, False: 0]
  ------------------
 6045|      0|    const Message msg =
 6046|      0|        Message() << "Invalid environment variables: we require 0 <= "
 6047|      0|                  << kTestShardIndex << " < " << kTestTotalShards
 6048|      0|                  << ", but you have " << kTestShardIndex << "=" << shard_index
 6049|      0|                  << ", " << kTestTotalShards << "=" << total_shards << ".\n";
 6050|      0|    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
 6051|      0|    fflush(stdout);
 6052|      0|    exit(EXIT_FAILURE);
 6053|      0|  }
 6054|       |
 6055|      0|  return total_shards > 1;
 6056|      4|}
_ZN7testing8internal17Int32FromEnvOrDieEPKci:
 6061|      8|int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
 6062|      8|  const char* str_val = posix::GetEnv(var);
 6063|      8|  if (str_val == nullptr) {
  ------------------
  |  Branch (6063:7): [True: 8, False: 0]
  ------------------
 6064|      8|    return default_val;
 6065|      8|  }
 6066|       |
 6067|      0|  int32_t result;
 6068|      0|  if (!ParseInt32(Message() << "The value of environment variable " << var,
  ------------------
  |  Branch (6068:7): [True: 0, False: 0]
  ------------------
 6069|      0|                  str_val, &result)) {
 6070|      0|    exit(EXIT_FAILURE);
 6071|      0|  }
 6072|      0|  return result;
 6073|      0|}
_ZN7testing8internal12UnitTestImpl11FilterTestsENS1_18ReactionToShardingE:
 6090|      2|int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
 6091|      2|  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (6091:32): [True: 0, False: 2]
  ------------------
 6092|      2|                                   ? Int32FromEnvOrDie(kTestTotalShards, -1)
 6093|      2|                                   : -1;
 6094|      2|  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL
  ------------------
  |  Branch (6094:31): [True: 0, False: 2]
  ------------------
 6095|      2|                                  ? Int32FromEnvOrDie(kTestShardIndex, -1)
 6096|      2|                                  : -1;
 6097|       |
 6098|      2|  const PositiveAndNegativeUnitTestFilter gtest_flag_filter(
 6099|      2|      GTEST_FLAG_GET(filter));
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6100|      2|  const UnitTestFilter disable_test_filter(kDisableTestFilter);
 6101|       |  // num_runnable_tests are the number of tests that will
 6102|       |  // run across all shards (i.e., match filter and are not disabled).
 6103|       |  // num_selected_tests are the number of tests to be run on
 6104|       |  // this shard.
 6105|      2|  int num_runnable_tests = 0;
 6106|      2|  int num_selected_tests = 0;
 6107|      2|  for (auto* test_suite : test_suites_) {
  ------------------
  |  Branch (6107:25): [True: 2, False: 2]
  ------------------
 6108|      2|    const std::string& test_suite_name = test_suite->name();
 6109|      2|    test_suite->set_should_run(false);
 6110|       |
 6111|      4|    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
  ------------------
  |  Branch (6111:24): [True: 2, False: 2]
  ------------------
 6112|      2|      TestInfo* const test_info = test_suite->test_info_list()[j];
 6113|      2|      const std::string test_name(test_info->name());
 6114|       |      // A test is disabled if test suite name or test name matches
 6115|       |      // kDisableTestFilter.
 6116|      2|      const bool is_disabled =
 6117|      2|          disable_test_filter.MatchesName(test_suite_name) ||
  ------------------
  |  Branch (6117:11): [True: 0, False: 2]
  ------------------
 6118|      2|          disable_test_filter.MatchesName(test_name);
  ------------------
  |  Branch (6118:11): [True: 0, False: 2]
  ------------------
 6119|      2|      test_info->is_disabled_ = is_disabled;
 6120|       |
 6121|      2|      const bool matches_filter =
 6122|      2|          gtest_flag_filter.MatchesTest(test_suite_name, test_name);
 6123|      2|      test_info->matches_filter_ = matches_filter;
 6124|       |
 6125|      2|      const bool is_runnable =
 6126|      2|          (GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
  ------------------
  |  | 2293|      2|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  ------------------
  |  |  |  | 2226|      2|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  |  |  |  Branch (2293:30): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (6126:55): [True: 2, False: 0]
  ------------------
 6127|      2|          matches_filter;
  ------------------
  |  Branch (6127:11): [True: 2, False: 0]
  ------------------
 6128|       |
 6129|      2|      const bool is_in_another_shard =
 6130|      2|          shard_tests != IGNORE_SHARDING_PROTOCOL &&
  ------------------
  |  Branch (6130:11): [True: 0, False: 2]
  ------------------
 6131|      0|          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
  ------------------
  |  Branch (6131:11): [True: 0, False: 0]
  ------------------
 6132|      2|      test_info->is_in_another_shard_ = is_in_another_shard;
 6133|      2|      const bool is_selected = is_runnable && !is_in_another_shard;
  ------------------
  |  Branch (6133:32): [True: 2, False: 0]
  |  Branch (6133:47): [True: 2, False: 0]
  ------------------
 6134|       |
 6135|      2|      num_runnable_tests += is_runnable;
 6136|      2|      num_selected_tests += is_selected;
 6137|       |
 6138|      2|      test_info->should_run_ = is_selected;
 6139|      2|      test_suite->set_should_run(test_suite->should_run() || is_selected);
  ------------------
  |  Branch (6139:34): [True: 0, False: 2]
  |  Branch (6139:62): [True: 2, False: 0]
  ------------------
 6140|      2|    }
 6141|      2|  }
 6142|      2|  return num_selected_tests;
 6143|      2|}
_ZN7testing8internal12UnitTestImpl21os_stack_trace_getterEv:
 6238|      8|OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
 6239|      8|  if (os_stack_trace_getter_ == nullptr) {
  ------------------
  |  Branch (6239:7): [True: 2, False: 6]
  ------------------
 6240|       |#ifdef GTEST_OS_STACK_TRACE_GETTER_
 6241|       |    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
 6242|       |#else
 6243|      2|    os_stack_trace_getter_ = new OsStackTraceGetter;
 6244|      2|#endif  // GTEST_OS_STACK_TRACE_GETTER_
 6245|      2|  }
 6246|       |
 6247|      8|  return os_stack_trace_getter_;
 6248|      8|}
_ZN7testing8internal12UnitTestImpl19current_test_resultEv:
 6251|     12|TestResult* UnitTestImpl::current_test_result() {
 6252|     12|  if (current_test_info_ != nullptr) {
  ------------------
  |  Branch (6252:7): [True: 8, False: 4]
  ------------------
 6253|      8|    return &current_test_info_->result_;
 6254|      8|  }
 6255|      4|  if (current_test_suite_ != nullptr) {
  ------------------
  |  Branch (6255:7): [True: 0, False: 4]
  ------------------
 6256|      0|    return &current_test_suite_->ad_hoc_test_result_;
 6257|      0|  }
 6258|      4|  return &ad_hoc_test_result_;
 6259|      4|}
_ZN7testing8internal6IsTrueEb:
 6310|     18|bool IsTrue(bool condition) { return condition; }
_ZN7testing8internal10AlwaysTrueEv:
 6312|     12|bool AlwaysTrue() {
 6313|     12|#if GTEST_HAS_EXCEPTIONS
 6314|       |  // This condition is always false so AlwaysTrue() never actually throws,
 6315|       |  // but it makes the compiler think that it may throw.
 6316|     12|  if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
  ------------------
  |  Branch (6316:7): [True: 0, False: 12]
  ------------------
 6317|     12|#endif  // GTEST_HAS_EXCEPTIONS
 6318|     12|  return true;
 6319|     12|}
_ZN7testing8internal10SkipPrefixEPKcPS2_:
 6324|     65|bool SkipPrefix(const char* prefix, const char** pstr) {
 6325|     65|  const size_t prefix_len = strlen(prefix);
 6326|     65|  if (strncmp(*pstr, prefix, prefix_len) == 0) {
  ------------------
  |  Branch (6326:7): [True: 13, False: 52]
  ------------------
 6327|     13|    *pstr += prefix_len;
 6328|     13|    return true;
 6329|     13|  }
 6330|     52|  return false;
 6331|     65|}
_ZN7testing8internal9ParseFlagEPKcS2_Pi:
 6392|     39|bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
 6393|       |  // Gets the value of the flag as a string.
 6394|     39|  const char* const value_str = ParseFlagValue(str, flag_name, false);
 6395|       |
 6396|       |  // Aborts if the parsing failed.
 6397|     39|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6397:7): [True: 39, False: 0]
  ------------------
 6398|       |
 6399|       |  // Sets *value to the value of the flag.
 6400|      0|  return ParseInt32(Message() << "The value of flag --" << flag_name, value_str,
 6401|      0|                    value);
 6402|     39|}
_ZN7testing8internal24ParseGoogleTestFlagsOnlyEPiPPc:
 6685|      2|void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
 6686|       |#ifdef GTEST_HAS_ABSL
 6687|       |  if (*argc <= 0) return;
 6688|       |
 6689|       |  std::vector<char*> positional_args;
 6690|       |  std::vector<absl::UnrecognizedFlag> unrecognized_flags;
 6691|       |  absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);
 6692|       |  absl::flat_hash_set<absl::string_view> unrecognized;
 6693|       |  for (const auto& flag : unrecognized_flags) {
 6694|       |    unrecognized.insert(flag.flag_name);
 6695|       |  }
 6696|       |  absl::flat_hash_set<char*> positional;
 6697|       |  for (const auto& arg : positional_args) {
 6698|       |    positional.insert(arg);
 6699|       |  }
 6700|       |
 6701|       |  int out_pos = 1;
 6702|       |  int in_pos = 1;
 6703|       |  for (; in_pos < *argc; ++in_pos) {
 6704|       |    char* arg = argv[in_pos];
 6705|       |    absl::string_view arg_str(arg);
 6706|       |    if (absl::ConsumePrefix(&arg_str, "--")) {
 6707|       |      // Flag-like argument. If the flag was unrecognized, keep it.
 6708|       |      // If it was a GoogleTest flag, remove it.
 6709|       |      if (unrecognized.contains(arg_str)) {
 6710|       |        argv[out_pos++] = argv[in_pos];
 6711|       |        continue;
 6712|       |      }
 6713|       |    }
 6714|       |
 6715|       |    if (arg_str.empty()) {
 6716|       |      ++in_pos;
 6717|       |      break;  // '--' indicates that the rest of the arguments are positional
 6718|       |    }
 6719|       |
 6720|       |    // Probably a positional argument. If it is in fact positional, keep it.
 6721|       |    // If it was a value for the flag argument, remove it.
 6722|       |    if (positional.contains(arg)) {
 6723|       |      argv[out_pos++] = arg;
 6724|       |    }
 6725|       |  }
 6726|       |
 6727|       |  // The rest are positional args for sure.
 6728|       |  while (in_pos < *argc) {
 6729|       |    argv[out_pos++] = argv[in_pos++];
 6730|       |  }
 6731|       |
 6732|       |  *argc = out_pos;
 6733|       |  argv[out_pos] = nullptr;
 6734|       |#else
 6735|      2|  ParseGoogleTestFlagsOnlyImpl(argc, argv);
 6736|      2|#endif
 6737|       |
 6738|       |  // Fix the value of *_NSGetArgc() on macOS, but if and only if
 6739|       |  // *_NSGetArgv() == argv
 6740|       |  // Only applicable to char** version of argv
 6741|       |#ifdef GTEST_OS_MAC
 6742|       |#ifndef GTEST_OS_IOS
 6743|       |  if (*_NSGetArgv() == argv) {
 6744|       |    *_NSGetArgc() = *argc;
 6745|       |  }
 6746|       |#endif
 6747|       |#endif
 6748|      2|}
_ZN7testing14InitGoogleTestEPiPPc:
 6794|      2|void InitGoogleTest(int* argc, char** argv) {
 6795|       |#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6796|       |  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
 6797|       |#else   // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6798|      2|  internal::InitGoogleTestImpl(argc, argv);
 6799|      2|#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
 6800|      2|}
gtest-all.cc:_ZN7testingL18GetDefaultFailFastEv:
  239|      2|static bool GetDefaultFailFast() {
  240|      2|  const char* const testbridge_test_runner_fail_fast =
  241|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
  242|      2|  if (testbridge_test_runner_fail_fast != nullptr) {
  ------------------
  |  Branch (242:7): [True: 0, False: 2]
  ------------------
  243|      0|    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
  244|      0|  }
  245|      2|  return false;
  246|      2|}
gtest-all.cc:_ZN7testingL16GetDefaultFilterEv:
  228|      2|static const char* GetDefaultFilter() {
  229|      2|  const char* const testbridge_test_only =
  230|      2|      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
  231|      2|  if (testbridge_test_only != nullptr) {
  ------------------
  |  Branch (231:7): [True: 0, False: 2]
  ------------------
  232|      0|    return testbridge_test_only;
  233|      0|  }
  234|      2|  return kUniversalFilter;
  235|      2|}
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  762|      6|  explicit UnitTestFilter(const std::string& filter) {
  763|       |    // By design "" filter matches "" string.
  764|      6|    std::vector<std::string> all_patterns;
  765|      6|    SplitString(filter, ':', &all_patterns);
  766|      6|    const auto exact_match_patterns_begin = std::partition(
  767|      6|        all_patterns.begin(), all_patterns.end(), &IsGlobPattern);
  768|       |
  769|      6|    glob_patterns_.reserve(static_cast<size_t>(
  770|      6|        std::distance(all_patterns.begin(), exact_match_patterns_begin)));
  771|      6|    std::move(all_patterns.begin(), exact_match_patterns_begin,
  772|      6|              std::inserter(glob_patterns_, glob_patterns_.begin()));
  773|      6|    std::move(
  774|      6|        exact_match_patterns_begin, all_patterns.end(),
  775|      6|        std::inserter(exact_match_patterns_, exact_match_patterns_.begin()));
  776|      6|  }
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  752|     10|bool IsGlobPattern(const std::string& pattern) {
  753|     10|  return std::any_of(pattern.begin(), pattern.end(),
  754|     10|                     [](const char c) { return c == '?' || c == '*'; });
  755|     10|}
gtest-all.cc:_ZZN7testing8internal12_GLOBAL__N_113IsGlobPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEENK3$_0clEc:
  754|     68|                     [](const char c) { return c == '?' || c == '*'; });
  ------------------
  |  Branch (754:48): [True: 0, False: 68]
  |  Branch (754:60): [True: 8, False: 60]
  ------------------
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  780|     10|  bool MatchesName(const std::string& name) const {
  781|     10|    return exact_match_patterns_.count(name) > 0 ||
  ------------------
  |  Branch (781:12): [True: 2, False: 8]
  ------------------
  782|      8|           std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
  ------------------
  |  Branch (782:12): [True: 0, False: 8]
  ------------------
  783|      8|                       [&name](const std::string& pattern) {
  784|      8|                         return PatternMatchesString(
  785|      8|                             name, pattern.c_str(),
  786|      8|                             pattern.c_str() + pattern.size());
  787|      8|                       });
  788|     10|  }
gtest-all.cc:_ZZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEENKUlSB_E_clESB_:
  783|     12|                       [&name](const std::string& pattern) {
  784|     12|                         return PatternMatchesString(
  785|     12|                             name, pattern.c_str(),
  786|     12|                             pattern.c_str() + pattern.size());
  787|     12|                       });
gtest-all.cc:_ZN7testing8internalL20PatternMatchesStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcSB_:
  704|     12|                                 const char* pattern, const char* pattern_end) {
  705|     12|  const char* name = name_str.c_str();
  706|     12|  const char* const name_begin = name;
  707|     12|  const char* const name_end = name + name_str.size();
  708|       |
  709|     12|  const char* pattern_next = pattern;
  710|     12|  const char* name_next = name;
  711|       |
  712|    164|  while (pattern < pattern_end || name < name_end) {
  ------------------
  |  Branch (712:10): [True: 164, False: 0]
  |  Branch (712:35): [True: 0, False: 0]
  ------------------
  713|    164|    if (pattern < pattern_end) {
  ------------------
  |  Branch (713:9): [True: 164, False: 0]
  ------------------
  714|    164|      switch (*pattern) {
  715|     84|        default:  // Match an ordinary character.
  ------------------
  |  Branch (715:9): [True: 84, False: 80]
  ------------------
  716|     84|          if (name < name_end && *name == *pattern) {
  ------------------
  |  Branch (716:15): [True: 76, False: 8]
  |  Branch (716:34): [True: 0, False: 76]
  ------------------
  717|      0|            ++pattern;
  718|      0|            ++name;
  719|      0|            continue;
  720|      0|          }
  721|     84|          break;
  722|     84|        case '?':  // Match any single character.
  ------------------
  |  Branch (722:9): [True: 0, False: 164]
  ------------------
  723|      0|          if (name < name_end) {
  ------------------
  |  Branch (723:15): [True: 0, False: 0]
  ------------------
  724|      0|            ++pattern;
  725|      0|            ++name;
  726|      0|            continue;
  727|      0|          }
  728|      0|          break;
  729|     80|        case '*':
  ------------------
  |  Branch (729:9): [True: 80, False: 84]
  ------------------
  730|       |          // Match zero or more characters. Start by skipping over the wildcard
  731|       |          // and matching zero characters from name. If that fails, restart and
  732|       |          // match one more character than the last attempt.
  733|     80|          pattern_next = pattern;
  734|     80|          name_next = name + 1;
  735|     80|          ++pattern;
  736|     80|          continue;
  737|    164|      }
  738|    164|    }
  739|       |    // Failed to match a character. Restart if possible.
  740|     84|    if (name_begin < name_next && name_next <= name_end) {
  ------------------
  |  Branch (740:9): [True: 80, False: 4]
  |  Branch (740:35): [True: 72, False: 8]
  ------------------
  741|     72|      pattern = pattern_next;
  742|     72|      name = name_next;
  743|     72|      continue;
  744|     72|    }
  745|     12|    return false;
  746|     84|  }
  747|      0|  return true;
  748|     12|}
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilterC2ERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  802|      2|  explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {
  803|      2|    std::vector<std::string> positive_and_negative_filters;
  804|       |
  805|       |    // NOTE: `SplitString` always returns a non-empty container.
  806|      2|    SplitString(filter, '-', &positive_and_negative_filters);
  807|      2|    const auto& positive_filter = positive_and_negative_filters.front();
  808|       |
  809|      2|    if (positive_and_negative_filters.size() > 1) {
  ------------------
  |  Branch (809:9): [True: 0, False: 2]
  ------------------
  810|      0|      positive_filter_ = UnitTestFilter(
  811|      0|          positive_filter.empty() ? kUniversalFilter : positive_filter);
  ------------------
  |  Branch (811:11): [True: 0, False: 0]
  ------------------
  812|       |
  813|       |      // TODO(b/214626361): Fail on multiple '-' characters
  814|       |      // For the moment to preserve old behavior we concatenate the rest of the
  815|       |      // string parts with `-` as separator to generate the negative filter.
  816|      0|      auto negative_filter_string = positive_and_negative_filters[1];
  817|      0|      for (std::size_t i = 2; i < positive_and_negative_filters.size(); i++)
  ------------------
  |  Branch (817:31): [True: 0, False: 0]
  ------------------
  818|      0|        negative_filter_string =
  819|      0|            negative_filter_string + '-' + positive_and_negative_filters[i];
  820|      0|      negative_filter_ = UnitTestFilter(negative_filter_string);
  821|      2|    } else {
  822|       |      // In case we don't have a negative filter and positive filter is ""
  823|       |      // we do not use kUniversalFilter by design as opposed to when we have a
  824|       |      // negative filter.
  825|      2|      positive_filter_ = UnitTestFilter(positive_filter);
  826|      2|    }
  827|      2|  }
gtest-all.cc:_ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2Ev:
  759|      4|  UnitTestFilter() = default;
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesTestERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_:
  833|      2|                   const std::string& test_name) const {
  834|      2|    return MatchesName(test_suite_name + "." + test_name);
  835|      2|  }
gtest-all.cc:_ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesNameERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  839|      2|  bool MatchesName(const std::string& name) const {
  840|      2|    return positive_filter_.MatchesName(name) &&
  ------------------
  |  Branch (840:12): [True: 2, False: 0]
  ------------------
  841|      2|           !negative_filter_.MatchesName(name);
  ------------------
  |  Branch (841:12): [True: 2, False: 0]
  ------------------
  842|      2|  }
gtest-all.cc:_ZN7testing8internalL18ShouldRunTestSuiteEPKNS_9TestSuiteE:
  445|      2|static bool ShouldRunTestSuite(const TestSuite* test_suite) {
  446|      2|  return test_suite->should_run();
  447|      2|}
gtest-all.cc:_ZN7testing8internalL20SumOverTestSuiteListERKNSt3__16vectorIPNS_9TestSuiteENS1_9allocatorIS4_EEEEMS3_KFivE:
  425|      2|                                int (TestSuite::*method)() const) {
  426|      2|  int sum = 0;
  427|      4|  for (size_t i = 0; i < case_list.size(); i++) {
  ------------------
  |  Branch (427:22): [True: 2, False: 2]
  ------------------
  428|      2|    sum += (case_list[i]->*method)();
  429|      2|  }
  430|      2|  return sum;
  431|      2|}
_ZN7testing8internal5TimerC2Ev:
 1151|      6|  Timer() : start_(clock::now()) {}
gtest-all.cc:_ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz:
 3279|     10|static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
 3280|     10|  va_list args;
 3281|     10|  va_start(args, fmt);
 3282|       |
 3283|     10|  static const bool in_color_mode =
 3284|     10|#if GTEST_HAS_FILE_SYSTEM
 3285|     10|      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
 3286|       |#else
 3287|       |      false;
 3288|       |#endif  // GTEST_HAS_FILE_SYSTEM
 3289|       |
 3290|     10|  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
  ------------------
  |  Branch (3290:26): [True: 0, False: 10]
  |  Branch (3290:43): [True: 0, False: 0]
  ------------------
 3291|       |
 3292|     10|  if (!use_color) {
  ------------------
  |  Branch (3292:7): [True: 10, False: 0]
  ------------------
 3293|     10|    vprintf(fmt, args);
 3294|     10|    va_end(args);
 3295|     10|    return;
 3296|     10|  }
 3297|       |
 3298|       |#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) &&    \
 3299|       |    !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
 3300|       |    !defined(GTEST_OS_WINDOWS_MINGW)
 3301|       |  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
 3302|       |
 3303|       |  // Gets the current text color.
 3304|       |  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
 3305|       |  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
 3306|       |  const WORD old_color_attrs = buffer_info.wAttributes;
 3307|       |  const WORD new_color = GetNewColor(color, old_color_attrs);
 3308|       |
 3309|       |  // We need to flush the stream buffers into the console before each
 3310|       |  // SetConsoleTextAttribute call lest it affect the text that is already
 3311|       |  // printed but has not yet reached the console.
 3312|       |  fflush(stdout);
 3313|       |  SetConsoleTextAttribute(stdout_handle, new_color);
 3314|       |
 3315|       |  vprintf(fmt, args);
 3316|       |
 3317|       |  fflush(stdout);
 3318|       |  // Restores the text color.
 3319|       |  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
 3320|       |#else
 3321|      0|  printf("\033[0;3%sm", GetAnsiColorCode(color));
 3322|      0|  vprintf(fmt, args);
 3323|      0|  printf("\033[m");  // Resets the terminal to default.
 3324|      0|#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
 3325|       |  va_end(args);
 3326|      0|}
gtest-all.cc:_ZN7testingL15FormatTestCountEi:
 3101|      2|static std::string FormatTestCount(int test_count) {
 3102|      2|  return FormatCountableNoun(test_count, "test", "tests");
 3103|      2|}
gtest-all.cc:_ZN7testingL20FormatTestSuiteCountEi:
 3106|      2|static std::string FormatTestSuiteCount(int test_suite_count) {
 3107|      2|  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
 3108|      2|}
gtest-all.cc:_ZN7testingL19FormatCountableNounEiPKcS1_:
 3095|      6|                                       const char* plural_form) {
 3096|      6|  return internal::StreamableToString(count) + " " +
 3097|      6|         (count == 1 ? singular_form : plural_form);
  ------------------
  |  Branch (3097:11): [True: 6, False: 0]
  ------------------
 3098|      6|}
_ZN7testing8internal27PrettyUnitTestResultPrinter13PrintTestNameEPKcS3_:
 3355|      2|  static void PrintTestName(const char* test_suite, const char* test) {
 3356|      2|    printf("%s.%s", test_suite, test);
 3357|      2|  }
_ZN7testing8internal17TestEventRepeaterC2Ev:
 3767|      2|  TestEventRepeater() : forwarding_enabled_(true) {}
_ZN7testing8internal23ScopedPrematureExitFileC2EPKc:
 5039|      2|      : premature_exit_filepath_(
 5040|      2|            premature_exit_filepath ? premature_exit_filepath : "") {
  ------------------
  |  Branch (5040:13): [True: 0, False: 2]
  ------------------
 5041|       |    // If a path to the premature-exit file is specified...
 5042|      2|    if (!premature_exit_filepath_.empty()) {
  ------------------
  |  Branch (5042:9): [True: 0, False: 2]
  ------------------
 5043|       |      // create the file with a single "0" character in it.  I/O
 5044|       |      // errors are ignored as there's nothing better we can do and we
 5045|       |      // don't want to fail the test because of this.
 5046|      0|      FILE* pfile = posix::FOpen(premature_exit_filepath_.c_str(), "w");
 5047|      0|      fwrite("0", 1, 1, pfile);
 5048|      0|      fclose(pfile);
 5049|      0|    }
 5050|      2|  }
_ZN7testing8internal27PrettyUnitTestResultPrinterC2Ev:
 3354|      2|  PrettyUnitTestResultPrinter() = default;
_ZN7testing8internal15TestSuiteNameIsC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
 5725|      2|  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
gtest-all.cc:_ZN7testing8internalL18GTestIsInitializedEv:
  419|      4|static bool GTestIsInitialized() { return !GetArgvs().empty(); }
gtest-all.cc:_ZN7testing8internalL14ParseFlagValueEPKcS2_b:
 6339|    286|                                  bool def_optional) {
 6340|       |  // str and flag must not be NULL.
 6341|    286|  if (str == nullptr || flag_name == nullptr) return nullptr;
  ------------------
  |  Branch (6341:7): [True: 0, False: 286]
  |  Branch (6341:25): [True: 0, False: 286]
  ------------------
 6342|       |
 6343|       |  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
 6344|    286|  const std::string flag_str =
 6345|    286|      std::string("--") + GTEST_FLAG_PREFIX_ + flag_name;
  ------------------
  |  |  331|    286|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
 6346|    286|  const size_t flag_len = flag_str.length();
 6347|    286|  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
  ------------------
  |  Branch (6347:7): [True: 286, False: 0]
  ------------------
 6348|       |
 6349|       |  // Skips the flag name.
 6350|      0|  const char* flag_end = str + flag_len;
 6351|       |
 6352|       |  // When def_optional is true, it's OK to not have a "=value" part.
 6353|      0|  if (def_optional && (flag_end[0] == '\0')) {
  ------------------
  |  Branch (6353:7): [True: 0, False: 0]
  |  Branch (6353:23): [True: 0, False: 0]
  ------------------
 6354|      0|    return flag_end;
 6355|      0|  }
 6356|       |
 6357|       |  // If def_optional is true and there are more characters after the
 6358|       |  // flag name, or if def_optional is false, there must be a '=' after
 6359|       |  // the flag name.
 6360|      0|  if (flag_end[0] != '=') return nullptr;
  ------------------
  |  Branch (6360:7): [True: 0, False: 0]
  ------------------
 6361|       |
 6362|       |  // Returns the string after "=".
 6363|      0|  return flag_end + 1;
 6364|      0|}
_ZN7testing8internal27PrettyUnitTestResultPrinter18OnTestProgramStartERKNS_8UnitTestE:
 3360|      2|  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
_ZN7testing8internal27PrettyUnitTestResultPrinter22OnEnvironmentsSetUpEndERKNS_8UnitTestE:
 3363|      2|  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc:
 2621|      4|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      4|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 4, False: 0]
  ------------------
 2646|      4|#if GTEST_HAS_EXCEPTIONS
 2647|      4|    try {
 2648|      4|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      4|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      4|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      4|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc:
 2602|      4|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      4|  (void)location;
 2612|      4|  return (object->*method)();
 2613|      4|#endif  // GTEST_HAS_SEH
 2614|      4|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc:
 2621|      2|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 2, False: 0]
  ------------------
 2646|      2|#if GTEST_HAS_EXCEPTIONS
 2647|      2|    try {
 2648|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      2|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      2|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_15TestFactoryBaseEPNS_4TestEEET0_PT_MS6_FS5_vEPKc:
 2602|      2|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      2|  (void)location;
 2612|      2|  return (object->*method)();
 2613|      2|#endif  // GTEST_HAS_SEH
 2614|      2|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc:
 2621|      2|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 2, False: 0]
  ------------------
 2646|      2|#if GTEST_HAS_EXCEPTIONS
 2647|      2|    try {
 2648|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      2|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      2|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_9TestSuiteEvEET0_PT_MS4_FS3_vEPKc:
 2602|      2|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      2|  (void)location;
 2612|      2|  return (object->*method)();
 2613|      2|#endif  // GTEST_HAS_SEH
 2614|      2|}
_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
 2621|      2|                                           const char* location) {
 2622|       |  // NOTE: The user code can affect the way in which Google Test handles
 2623|       |  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
 2624|       |  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
 2625|       |  // after the exception is caught and either report or re-throw the
 2626|       |  // exception based on the flag's value:
 2627|       |  //
 2628|       |  // try {
 2629|       |  //   // Perform the test method.
 2630|       |  // } catch (...) {
 2631|       |  //   if (GTEST_FLAG_GET(catch_exceptions))
 2632|       |  //     // Report the exception as failure.
 2633|       |  //   else
 2634|       |  //     throw;  // Re-throws the original exception.
 2635|       |  // }
 2636|       |  //
 2637|       |  // However, the purpose of this flag is to allow the program to drop into
 2638|       |  // the debugger when the exception is thrown. On most platforms, once the
 2639|       |  // control enters the catch block, the exception origin information is
 2640|       |  // lost and the debugger will stop the program at the point of the
 2641|       |  // re-throw in this function -- instead of at the point of the original
 2642|       |  // throw statement in the code under test.  For this reason, we perform
 2643|       |  // the check early, sacrificing the ability to affect Google Test's
 2644|       |  // exception handling in the method where the exception is thrown.
 2645|      2|  if (internal::GetUnitTestImpl()->catch_exceptions()) {
  ------------------
  |  Branch (2645:7): [True: 2, False: 0]
  ------------------
 2646|      2|#if GTEST_HAS_EXCEPTIONS
 2647|      2|    try {
 2648|      2|      return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2649|      2|    } catch (const AssertionException&) {  // NOLINT
 2650|       |      // This failure was reported already.
 2651|      0|    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
 2652|       |      // This exception type can only be thrown by a failed Google
 2653|       |      // Test assertion with the intention of letting another testing
 2654|       |      // framework catch it.  Therefore we just re-throw it.
 2655|      0|      throw;
 2656|      0|    } catch (const std::exception& e) {  // NOLINT
 2657|      0|      internal::ReportFailureInUnknownLocation(
 2658|      0|          TestPartResult::kFatalFailure,
 2659|      0|          FormatCxxExceptionMessage(e.what(), location));
 2660|      0|    } catch (...) {  // NOLINT
 2661|      0|      internal::ReportFailureInUnknownLocation(
 2662|      0|          TestPartResult::kFatalFailure,
 2663|      0|          FormatCxxExceptionMessage(nullptr, location));
 2664|      0|    }
 2665|      0|    return static_cast<Result>(0);
 2666|       |#else
 2667|       |    return HandleSehExceptionsInMethodIfSupported(object, method, location);
 2668|       |#endif  // GTEST_HAS_EXCEPTIONS
 2669|      2|  } else {
 2670|      0|    return (object->*method)();
 2671|      0|  }
 2672|      2|}
_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
 2602|      2|                                              const char* location) {
 2603|       |#if GTEST_HAS_SEH
 2604|       |  __try {
 2605|       |    return (object->*method)();
 2606|       |  } __except (internal::UnitTestOptions::GTestProcessSEH(  // NOLINT
 2607|       |      GetExceptionCode(), location)) {
 2608|       |    return static_cast<Result>(0);
 2609|       |  }
 2610|       |#else
 2611|      2|  (void)location;
 2612|      2|  return (object->*method)();
 2613|      2|#endif  // GTEST_HAS_SEH
 2614|      2|}
_ZN7testing8internal28ParseGoogleTestFlagsOnlyImplIcEEvPiPPT_:
 6630|      2|void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
 6631|      2|  std::string flagfile_value;
 6632|     15|  for (int i = 1; i < *argc; i++) {
  ------------------
  |  Branch (6632:19): [True: 13, False: 2]
  ------------------
 6633|     13|    const std::string arg_string = StreamableToString(argv[i]);
 6634|     13|    const char* const arg = arg_string.c_str();
 6635|       |
 6636|     13|    using internal::ParseFlag;
 6637|       |
 6638|     13|    bool remove_flag = false;
 6639|     13|    if (ParseGoogleTestFlag(arg)) {
  ------------------
  |  Branch (6639:9): [True: 0, False: 13]
  ------------------
 6640|      0|      remove_flag = true;
 6641|      0|#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 6642|     13|    } else if (ParseFlag(arg, "flagfile", &flagfile_value)) {
  ------------------
  |  Branch (6642:16): [True: 0, False: 13]
  ------------------
 6643|      0|      GTEST_FLAG_SET(flagfile, flagfile_value);
  ------------------
  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  ------------------
  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  ------------------
  ------------------
 6644|      0|      LoadFlagsFromFile(flagfile_value);
 6645|      0|      remove_flag = true;
 6646|      0|#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
 6647|     13|    } else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
  ------------------
  |  Branch (6647:16): [True: 0, False: 13]
  |  Branch (6647:42): [True: 0, False: 13]
  ------------------
 6648|       |      // Both help flag and unrecognized Google Test flags (excluding
 6649|       |      // internal ones) trigger help display.
 6650|      0|      g_help_flag = true;
 6651|      0|    }
 6652|       |
 6653|     13|    if (remove_flag) {
  ------------------
  |  Branch (6653:9): [True: 0, False: 13]
  ------------------
 6654|       |      // Shift the remainder of the argv list left by one.  Note
 6655|       |      // that argv has (*argc + 1) elements, the last one always being
 6656|       |      // NULL.  The following loop moves the trailing NULL element as
 6657|       |      // well.
 6658|      0|      for (int j = i; j != *argc; j++) {
  ------------------
  |  Branch (6658:23): [True: 0, False: 0]
  ------------------
 6659|      0|        argv[j] = argv[j + 1];
 6660|      0|      }
 6661|       |
 6662|       |      // Decrements the argument count.
 6663|      0|      (*argc)--;
 6664|       |
 6665|       |      // We also need to decrement the iterator as we just removed
 6666|       |      // an element.
 6667|      0|      i--;
 6668|      0|    }
 6669|     13|  }
 6670|       |
 6671|      2|  if (g_help_flag) {
  ------------------
  |  Branch (6671:7): [True: 0, False: 2]
  ------------------
 6672|       |    // We print the help here instead of in RUN_ALL_TESTS(), as the
 6673|       |    // latter may not be called at all if the user is using Google
 6674|       |    // Test with another testing framework.
 6675|      0|    PrintColorEncoded(kColorEncodedHelpMessage);
 6676|      0|  }
 6677|      2|}
gtest-all.cc:_ZN7testing8internalL19ParseGoogleTestFlagEPKc:
 6574|     13|static bool ParseGoogleTestFlag(const char* const arg) {
 6575|     13|#define GTEST_INTERNAL_PARSE_FLAG(flag_name)  \
 6576|     13|  do {                                        \
 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
 6579|     13|      GTEST_FLAG_SET(flag_name, value);       \
 6580|     13|      return true;                            \
 6581|     13|    }                                         \
 6582|     13|  } while (false)
 6583|       |
 6584|     13|  GTEST_INTERNAL_PARSE_FLAG(also_run_disabled_tests);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6585|     13|  GTEST_INTERNAL_PARSE_FLAG(break_on_failure);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6586|     13|  GTEST_INTERNAL_PARSE_FLAG(catch_exceptions);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6587|     13|  GTEST_INTERNAL_PARSE_FLAG(color);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6588|     13|  GTEST_INTERNAL_PARSE_FLAG(death_test_style);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6589|     13|  GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6590|     13|  GTEST_INTERNAL_PARSE_FLAG(fail_fast);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6591|     13|  GTEST_INTERNAL_PARSE_FLAG(filter);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6592|     13|  GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6593|     13|  GTEST_INTERNAL_PARSE_FLAG(list_tests);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6594|     13|  GTEST_INTERNAL_PARSE_FLAG(output);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6595|     13|  GTEST_INTERNAL_PARSE_FLAG(brief);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6596|     13|  GTEST_INTERNAL_PARSE_FLAG(print_time);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6597|     13|  GTEST_INTERNAL_PARSE_FLAG(print_utf8);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6598|     13|  GTEST_INTERNAL_PARSE_FLAG(random_seed);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6599|     13|  GTEST_INTERNAL_PARSE_FLAG(repeat);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6600|     13|  GTEST_INTERNAL_PARSE_FLAG(recreate_environments_when_repeating);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6601|     13|  GTEST_INTERNAL_PARSE_FLAG(shuffle);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6602|     13|  GTEST_INTERNAL_PARSE_FLAG(stack_trace_depth);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6603|     13|  GTEST_INTERNAL_PARSE_FLAG(stream_result_to);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6604|     13|  GTEST_INTERNAL_PARSE_FLAG(throw_on_failure);
  ------------------
  |  | 6576|     13|  do {                                        \
  |  | 6577|     13|    auto value = GTEST_FLAG_GET(flag_name);   \
  |  |  ------------------
  |  |  |  | 2293|     13|#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|     13|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6578|     13|    if (ParseFlag(arg, #flag_name, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6578:9): [True: 0, False: 13]
  |  |  ------------------
  |  | 6579|      0|      GTEST_FLAG_SET(flag_name, value);       \
  |  |  ------------------
  |  |  |  | 2294|      0|#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
  |  |  |  |  ------------------
  |  |  |  |  |  | 2226|      0|#define GTEST_FLAG(name) FLAGS_gtest_##name
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6580|      0|      return true;                            \
  |  | 6581|      0|    }                                         \
  |  | 6582|     13|  } while (false)
  |  |  ------------------
  |  |  |  Branch (6582:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
 6605|     13|  return false;
 6606|     13|}
gtest-all.cc:_ZN7testing8internalL9ParseFlagEPKcS2_Pb:
 6376|    156|static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
 6377|       |  // Gets the value of the flag as a string.
 6378|    156|  const char* const value_str = ParseFlagValue(str, flag_name, true);
 6379|       |
 6380|       |  // Aborts if the parsing failed.
 6381|    156|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6381:7): [True: 156, False: 0]
  ------------------
 6382|       |
 6383|       |  // Converts the string value to a bool.
 6384|      0|  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
  ------------------
  |  Branch (6384:14): [True: 0, False: 0]
  |  Branch (6384:35): [True: 0, False: 0]
  |  Branch (6384:56): [True: 0, False: 0]
  ------------------
 6385|      0|  return true;
 6386|    156|}
gtest-all.cc:_ZN7testing8internalL9ParseFlagINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEbPKcSA_PT_:
 6409|     91|static bool ParseFlag(const char* str, const char* flag_name, String* value) {
 6410|       |  // Gets the value of the flag as a string.
 6411|     91|  const char* const value_str = ParseFlagValue(str, flag_name, false);
 6412|       |
 6413|       |  // Aborts if the parsing failed.
 6414|     91|  if (value_str == nullptr) return false;
  ------------------
  |  Branch (6414:7): [True: 91, False: 0]
  ------------------
 6415|       |
 6416|       |  // Sets *value to the value of the flag.
 6417|      0|  *value = value_str;
 6418|      0|  return true;
 6419|     91|}
gtest-all.cc:_ZN7testing8internalL23HasGoogleTestFlagPrefixEPKc:
 6427|     13|static bool HasGoogleTestFlagPrefix(const char* str) {
 6428|     13|  return (SkipPrefix("--", &str) || SkipPrefix("-", &str) ||
  ------------------
  |  Branch (6428:11): [True: 4, False: 9]
  |  Branch (6428:37): [True: 5, False: 4]
  ------------------
 6429|      4|          SkipPrefix("/", &str)) &&
  ------------------
  |  Branch (6429:11): [True: 4, False: 0]
  ------------------
 6430|     13|         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
  ------------------
  |  |  331|     13|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
  |  Branch (6430:10): [True: 13, False: 0]
  ------------------
 6431|     13|         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
  ------------------
  |  |  331|     13|#define GTEST_FLAG_PREFIX_ "gtest_"
  ------------------
  |  Branch (6431:11): [True: 0, False: 13]
  ------------------
 6432|     13|          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
  ------------------
  |  |  332|     13|#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
  ------------------
  |  Branch (6432:11): [True: 0, False: 13]
  ------------------
 6433|     13|}
_ZN7testing8internal18InitGoogleTestImplIcEEvPiPPT_:
 6758|      2|void InitGoogleTestImpl(int* argc, CharType** argv) {
 6759|       |  // We don't want to run the initialization code twice.
 6760|      2|  if (GTestIsInitialized()) return;
  ------------------
  |  Branch (6760:7): [True: 0, False: 2]
  ------------------
 6761|       |
 6762|      2|  if (*argc <= 0) return;
  ------------------
  |  Branch (6762:7): [True: 0, False: 2]
  ------------------
 6763|       |
 6764|      2|  g_argvs.clear();
 6765|     17|  for (int i = 0; i != *argc; i++) {
  ------------------
  |  Branch (6765:19): [True: 15, False: 2]
  ------------------
 6766|     15|    g_argvs.push_back(StreamableToString(argv[i]));
 6767|     15|  }
 6768|       |
 6769|       |#ifdef GTEST_HAS_ABSL
 6770|       |  absl::InitializeSymbolizer(g_argvs[0].c_str());
 6771|       |
 6772|       |  // When using the Abseil Flags library, set the program usage message to the
 6773|       |  // help message, but remove the color-encoding from the message first.
 6774|       |  absl::SetProgramUsageMessage(absl::StrReplaceAll(
 6775|       |      kColorEncodedHelpMessage,
 6776|       |      {{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
 6777|       |#endif  // GTEST_HAS_ABSL
 6778|       |
 6779|      2|  ParseGoogleTestFlagsOnly(argc, argv);
 6780|      2|  GetUnitTestImpl()->PostFlagParsingInit();
 6781|      2|}

webp_info_fuzzer.cc:_ZL12WebPInfoInitP8WebPInfo:
  115|  1.18k|static void WebPInfoInit(WebPInfo* const webp_info) {
  116|  1.18k|  memset(webp_info, 0, sizeof(*webp_info));
  117|  1.18k|}
webp_info_fuzzer.cc:_ZL11AnalyzeWebPP8WebPInfoPK8WebPData:
 1067|  1.18k|                                  const WebPData* webp_data) {
 1068|  1.18k|  ChunkData chunk_data;
 1069|  1.18k|  MemBuffer mem_buffer;
 1070|  1.18k|  WebPInfoStatus webp_info_status = WEBP_INFO_OK;
 1071|       |
 1072|  1.18k|  InitMemBuffer(&mem_buffer, webp_data);
 1073|  1.18k|  webp_info_status = ParseRIFFHeader(webp_info, &mem_buffer);
 1074|  1.18k|  if (webp_info_status != WEBP_INFO_OK) goto Error;
  ------------------
  |  Branch (1074:7): [True: 188, False: 995]
  ------------------
 1075|       |
 1076|       |  //  Loop through all the chunks. Terminate immediately in case of error.
 1077|  2.43k|  while (webp_info_status == WEBP_INFO_OK && MemDataSize(&mem_buffer) > 0) {
  ------------------
  |  Branch (1077:10): [True: 2.04k, False: 393]
  |  Branch (1077:46): [True: 1.55k, False: 488]
  ------------------
 1078|  1.55k|    webp_info_status = ParseChunk(webp_info, &mem_buffer, &chunk_data);
 1079|  1.55k|    if (webp_info_status != WEBP_INFO_OK) goto Error;
  ------------------
  |  Branch (1079:9): [True: 114, False: 1.43k]
  ------------------
 1080|  1.43k|    webp_info_status = ProcessChunk(&chunk_data, webp_info);
 1081|  1.43k|  }
 1082|    881|  if (webp_info_status != WEBP_INFO_OK) goto Error;
  ------------------
  |  Branch (1082:7): [True: 393, False: 488]
  ------------------
 1083|    488|  if (webp_info->show_summary) ShowSummary(webp_info);
  ------------------
  |  Branch (1083:7): [True: 0, False: 488]
  ------------------
 1084|       |
 1085|       |  //  Final check.
 1086|    488|  webp_info_status = Validate(webp_info);
 1087|       |
 1088|  1.18k|Error:
 1089|  1.18k|  if (!webp_info->quiet) {
  ------------------
  |  Branch (1089:7): [True: 0, False: 1.18k]
  ------------------
 1090|      0|    if (webp_info_status == WEBP_INFO_OK) {
  ------------------
  |  Branch (1090:9): [True: 0, False: 0]
  ------------------
 1091|      0|      printf("No error detected.\n");
 1092|      0|    } else {
 1093|      0|      printf("Errors detected.\n");
 1094|      0|    }
 1095|      0|    if (webp_info->num_warnings > 0) {
  ------------------
  |  Branch (1095:9): [True: 0, False: 0]
  ------------------
 1096|      0|      printf("There were %d warning(s).\n", webp_info->num_warnings);
 1097|      0|    }
 1098|      0|  }
 1099|  1.18k|  return webp_info_status;
 1100|    488|}
webp_info_fuzzer.cc:_ZL13InitMemBufferP9MemBufferPK8WebPData:
  177|  1.18k|static void InitMemBuffer(MemBuffer* const mem, const WebPData* webp_data) {
  178|  1.18k|  mem->buf = webp_data->bytes;
  179|  1.18k|  mem->start = 0;
  180|  1.18k|  mem->end = webp_data->size;
  181|  1.18k|}
webp_info_fuzzer.cc:_ZL15ParseRIFFHeaderP8WebPInfoP9MemBuffer:
  578|  1.18k|                                      MemBuffer* const mem) {
  579|  1.18k|  const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  ------------------
  |  |   76|  1.18k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                const size_t min_size = RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|  1.18k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  580|  1.18k|  size_t riff_size;
  581|       |
  582|  1.18k|  if (MemDataSize(mem) < min_size) {
  ------------------
  |  Branch (582:7): [True: 34, False: 1.14k]
  ------------------
  583|     34|    LOG_ERROR("Truncated data detected when parsing RIFF header.");
  ------------------
  |  |   36|     34|  do {                                         \
  |  |   37|     34|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 34]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     34|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 34]
  |  |  ------------------
  ------------------
  584|     34|    return WEBP_INFO_TRUNCATED_DATA;
  585|     34|  }
  586|  1.14k|  if (memcmp(GetBuffer(mem), "RIFF", CHUNK_SIZE_BYTES) ||
  ------------------
  |  |   74|  1.14k|#define CHUNK_SIZE_BYTES 4   // Size needed to store chunk's size.
  ------------------
  |  Branch (586:7): [True: 62, False: 1.08k]
  ------------------
  587|  1.08k|      memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {
  ------------------
  |  |   75|  1.08k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                    memcmp(GetBuffer(mem) + CHUNK_HEADER_SIZE, "WEBP", CHUNK_SIZE_BYTES)) {
  ------------------
  |  |   74|  1.08k|#define CHUNK_SIZE_BYTES 4   // Size needed to store chunk's size.
  ------------------
  |  Branch (587:7): [True: 4, False: 1.08k]
  ------------------
  588|     66|    LOG_ERROR("Corrupted RIFF header.");
  ------------------
  |  |   36|     66|  do {                                         \
  |  |   37|     66|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 66]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     66|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 66]
  |  |  ------------------
  ------------------
  589|     66|    return WEBP_INFO_PARSE_ERROR;
  590|     66|  }
  591|  1.08k|  riff_size = GetLE32(GetBuffer(mem) + TAG_SIZE);
  ------------------
  |  |   73|  1.08k|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  592|  1.08k|  if (riff_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|  1.08k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (592:7): [True: 3, False: 1.08k]
  ------------------
  593|      3|    LOG_ERROR("RIFF size is too small.");
  ------------------
  |  |   36|      3|  do {                                         \
  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      3|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  ------------------
  ------------------
  594|      3|    return WEBP_INFO_PARSE_ERROR;
  595|      3|  }
  596|  1.08k|  if (riff_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|  1.08k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|  1.08k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (596:7): [True: 3, False: 1.07k]
  ------------------
  597|      3|    LOG_ERROR("RIFF size is over limit.");
  ------------------
  |  |   36|      3|  do {                                         \
  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      3|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  ------------------
  ------------------
  598|      3|    return WEBP_INFO_PARSE_ERROR;
  599|      3|  }
  600|  1.07k|  riff_size += CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|  1.07k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  601|  1.07k|  if (!webp_info->quiet) {
  ------------------
  |  Branch (601:7): [True: 0, False: 1.07k]
  ------------------
  602|      0|    printf("RIFF HEADER:\n");
  603|      0|    printf("  File size: %6d\n", (int)riff_size);
  604|      0|  }
  605|  1.07k|  if (riff_size < mem->end) {
  ------------------
  |  Branch (605:7): [True: 4, False: 1.07k]
  ------------------
  606|      4|    LOG_WARN("RIFF size is smaller than the file size.");
  ------------------
  |  |   43|      4|  do {                                           \
  |  |   44|      4|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 4]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      4|    ++webp_info->num_warnings;                   \
  |  |   48|      4|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 4]
  |  |  ------------------
  ------------------
  607|      4|    mem->end = riff_size;
  608|  1.07k|  } else if (riff_size > mem->end) {
  ------------------
  |  Branch (608:14): [True: 82, False: 991]
  ------------------
  609|     82|    LOG_ERROR("Truncated data detected when parsing RIFF payload.");
  ------------------
  |  |   36|     82|  do {                                         \
  |  |   37|     82|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 82]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     82|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 82]
  |  |  ------------------
  ------------------
  610|     82|    return WEBP_INFO_TRUNCATED_DATA;
  611|     82|  }
  612|    995|  Skip(mem, RIFF_HEADER_SIZE);
  ------------------
  |  |   76|    995|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  613|    995|  return WEBP_INFO_OK;
  614|  1.07k|}
webp_info_fuzzer.cc:_ZL9GetBufferP9MemBuffer:
  187|  4.75k|static const uint8_t* GetBuffer(MemBuffer* const mem) {
  188|  4.75k|  return mem->buf + mem->start;
  189|  4.75k|}
webp_info_fuzzer.cc:_ZL7GetLE32PKh:
  142|  4.13k|static uint32_t GetLE32(const uint8_t* const data) {
  143|  4.13k|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  144|  4.13k|}
webp_info_fuzzer.cc:_ZL7GetLE16PKh:
  134|  8.44k|static int GetLE16(const uint8_t* const data) {
  135|  8.44k|  return (data[0] << 0) | (data[1] << 8);
  136|  8.44k|}
webp_info_fuzzer.cc:_ZL4SkipP9MemBufferm:
  191|  5.48k|static void Skip(MemBuffer* const mem, size_t size) { mem->start += size; }
webp_info_fuzzer.cc:_ZL11MemDataSizePK9MemBuffer:
  183|  6.29k|static size_t MemDataSize(const MemBuffer* const mem) {
  184|  6.29k|  return (mem->end - mem->start);
  185|  6.29k|}
webp_info_fuzzer.cc:_ZL10ParseChunkPK8WebPInfoP9MemBufferP9ChunkData:
  618|  1.55k|                                 ChunkData* const chunk_data) {
  619|  1.55k|  memset(chunk_data, 0, sizeof(*chunk_data));
  620|  1.55k|  if (MemDataSize(mem) < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|  1.55k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (620:7): [True: 27, False: 1.52k]
  ------------------
  621|     27|    LOG_ERROR("Truncated data detected when parsing chunk header.");
  ------------------
  |  |   36|     27|  do {                                         \
  |  |   37|     27|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 27]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     27|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 27]
  |  |  ------------------
  ------------------
  622|     27|    return WEBP_INFO_TRUNCATED_DATA;
  623|  1.52k|  } else {
  624|  1.52k|    const size_t chunk_start_offset = mem->start;
  625|  1.52k|    const uint32_t fourcc = ReadMemBufLE32(mem);
  626|  1.52k|    const uint32_t payload_size = ReadMemBufLE32(mem);
  627|  1.52k|    const uint32_t payload_size_padded = payload_size + (payload_size & 1);
  628|  1.52k|    const size_t chunk_size = CHUNK_HEADER_SIZE + payload_size_padded;
  ------------------
  |  |   75|  1.52k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  629|  1.52k|    int i;
  630|  1.52k|    if (payload_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|  1.52k|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|  1.52k|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (630:9): [True: 1, False: 1.52k]
  ------------------
  631|      1|      LOG_ERROR("Size of chunk payload is over limit.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  632|      1|      return WEBP_INFO_INVALID_PARAM;
  633|      1|    }
  634|  1.52k|    if (payload_size_padded > MemDataSize(mem)) {
  ------------------
  |  Branch (634:9): [True: 85, False: 1.43k]
  ------------------
  635|     85|      LOG_ERROR("Truncated data detected when parsing chunk payload.");
  ------------------
  |  |   36|     85|  do {                                         \
  |  |   37|     85|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 85]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     85|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 85]
  |  |  ------------------
  ------------------
  636|     85|      return WEBP_INFO_TRUNCATED_DATA;
  637|     85|    }
  638|  9.01k|    for (i = 0; i < CHUNK_TYPES; ++i) {
  ------------------
  |  Branch (638:17): [True: 8.21k, False: 803]
  ------------------
  639|  8.21k|      if (kWebPChunkTags[i] == fourcc) break;
  ------------------
  |  Branch (639:11): [True: 636, False: 7.57k]
  ------------------
  640|  8.21k|    }
  641|  1.43k|    chunk_data->offset = chunk_start_offset;
  642|  1.43k|    chunk_data->size = chunk_size;
  643|  1.43k|    chunk_data->id = (ChunkID)i;
  644|  1.43k|    chunk_data->payload = GetBuffer(mem);
  645|  1.43k|    if (chunk_data->id == CHUNK_ANMF) {
  ------------------
  |  Branch (645:9): [True: 2, False: 1.43k]
  ------------------
  646|      2|      if (payload_size != payload_size_padded) {
  ------------------
  |  Branch (646:11): [True: 1, False: 1]
  ------------------
  647|      1|        LOG_ERROR("ANMF chunk size should always be even.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  648|      1|        return WEBP_INFO_PARSE_ERROR;
  649|      1|      }
  650|       |      // There are sub-chunks to be parsed in an ANMF chunk.
  651|      1|      Skip(mem, ANMF_CHUNK_SIZE);
  ------------------
  |  |   77|      1|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
  652|  1.43k|    } else {
  653|  1.43k|      Skip(mem, payload_size_padded);
  654|  1.43k|    }
  655|  1.43k|    return WEBP_INFO_OK;
  656|  1.43k|  }
  657|  1.55k|}
webp_info_fuzzer.cc:_ZL14ReadMemBufLE32P9MemBuffer:
  193|  3.05k|static uint32_t ReadMemBufLE32(MemBuffer* const mem) {
  194|  3.05k|  const uint8_t* const data = mem->buf + mem->start;
  195|  3.05k|  const uint32_t val = GetLE32(data);
  196|       |  assert(MemDataSize(mem) >= 4);
  197|  3.05k|  Skip(mem, 4);
  198|  3.05k|  return val;
  199|  3.05k|}
webp_info_fuzzer.cc:_ZL12ProcessChunkPK9ChunkDataP8WebPInfo:
  924|  1.43k|                                   WebPInfo* const webp_info) {
  925|  1.43k|  WebPInfoStatus status = WEBP_INFO_OK;
  926|  1.43k|  ChunkID id = chunk_data->id;
  927|  1.43k|  if (chunk_data->id == CHUNK_UNKNOWN) {
  ------------------
  |  Branch (927:7): [True: 803, False: 635]
  ------------------
  928|    803|    char error_message[50];
  929|    803|    snprintf(error_message, 50, "Unknown chunk at offset %6d, length %6d",
  930|    803|             (int)chunk_data->offset, (int)chunk_data->size);
  931|    803|    LOG_WARN(error_message);
  ------------------
  |  |   43|    803|  do {                                           \
  |  |   44|    803|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 803]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|    803|    ++webp_info->num_warnings;                   \
  |  |   48|    803|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 803]
  |  |  ------------------
  ------------------
  932|    803|  } else {
  933|    635|    if (!webp_info->quiet) {
  ------------------
  |  Branch (933:9): [True: 0, False: 635]
  ------------------
  934|      0|      char tag[4];
  935|      0|      uint32_t fourcc = kWebPChunkTags[chunk_data->id];
  936|       |#ifdef WORDS_BIGENDIAN
  937|       |      fourcc = (fourcc >> 24) | ((fourcc >> 8) & 0xff00) |
  938|       |               ((fourcc << 8) & 0xff0000) | (fourcc << 24);
  939|       |#endif
  940|      0|      memcpy(tag, &fourcc, sizeof(tag));
  941|      0|      printf("Chunk %c%c%c%c at offset %6d, length %6d\n", tag[0], tag[1],
  942|      0|             tag[2], tag[3], (int)chunk_data->offset, (int)chunk_data->size);
  943|      0|    }
  944|    635|  }
  945|  1.43k|  switch (id) {
  946|    420|    case CHUNK_VP8:
  ------------------
  |  Branch (946:5): [True: 420, False: 1.01k]
  ------------------
  947|    528|    case CHUNK_VP8L:
  ------------------
  |  Branch (947:5): [True: 108, False: 1.33k]
  ------------------
  948|    528|      status = ProcessImageChunk(chunk_data, webp_info);
  949|    528|      break;
  950|    100|    case CHUNK_VP8X:
  ------------------
  |  Branch (950:5): [True: 100, False: 1.33k]
  ------------------
  951|    100|      status = ProcessVP8XChunk(chunk_data, webp_info);
  952|    100|      break;
  953|      1|    case CHUNK_ALPHA:
  ------------------
  |  Branch (953:5): [True: 1, False: 1.43k]
  ------------------
  954|      1|      status = ProcessALPHChunk(chunk_data, webp_info);
  955|      1|      break;
  956|      1|    case CHUNK_ANIM:
  ------------------
  |  Branch (956:5): [True: 1, False: 1.43k]
  ------------------
  957|      1|      status = ProcessANIMChunk(chunk_data, webp_info);
  958|      1|      break;
  959|      1|    case CHUNK_ANMF:
  ------------------
  |  Branch (959:5): [True: 1, False: 1.43k]
  ------------------
  960|      1|      status = ProcessANMFChunk(chunk_data, webp_info);
  961|      1|      break;
  962|      2|    case CHUNK_ICCP:
  ------------------
  |  Branch (962:5): [True: 2, False: 1.43k]
  ------------------
  963|      2|      status = ProcessICCPChunk(chunk_data, webp_info);
  964|      2|      break;
  965|      1|    case CHUNK_EXIF:
  ------------------
  |  Branch (965:5): [True: 1, False: 1.43k]
  ------------------
  966|      2|    case CHUNK_XMP:
  ------------------
  |  Branch (966:5): [True: 1, False: 1.43k]
  ------------------
  967|      2|      ++webp_info->chunk_counts[id];
  968|      2|      break;
  969|    803|    case CHUNK_UNKNOWN:
  ------------------
  |  Branch (969:5): [True: 803, False: 635]
  ------------------
  970|    803|    default:
  ------------------
  |  Branch (970:5): [True: 0, False: 1.43k]
  ------------------
  971|    803|      break;
  972|  1.43k|  }
  973|  1.43k|  if (webp_info->is_processing_anim_frame && id != CHUNK_ANMF) {
  ------------------
  |  Branch (973:7): [True: 0, False: 1.43k]
  |  Branch (973:46): [True: 0, False: 0]
  ------------------
  974|      0|    if (webp_info->anim_frame_data_size == chunk_data->size) {
  ------------------
  |  Branch (974:9): [True: 0, False: 0]
  ------------------
  975|      0|      if (!webp_info->seen_image_subchunk) {
  ------------------
  |  Branch (975:11): [True: 0, False: 0]
  ------------------
  976|      0|        LOG_ERROR("No VP8/VP8L chunk detected in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  977|      0|        return WEBP_INFO_PARSE_ERROR;
  978|      0|      }
  979|      0|      webp_info->is_processing_anim_frame = 0;
  980|      0|    } else if (webp_info->anim_frame_data_size > chunk_data->size) {
  ------------------
  |  Branch (980:16): [True: 0, False: 0]
  ------------------
  981|      0|      webp_info->anim_frame_data_size -= chunk_data->size;
  982|      0|    } else {
  983|      0|      LOG_ERROR("Truncated data detected when parsing ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  984|      0|      return WEBP_INFO_TRUNCATED_DATA;
  985|      0|    }
  986|      0|  }
  987|  1.43k|  return status;
  988|  1.43k|}
webp_info_fuzzer.cc:_ZL17ProcessImageChunkPK9ChunkDataP8WebPInfo:
  784|    528|                                        WebPInfo* const webp_info) {
  785|    528|  const uint8_t* data = chunk_data->payload - CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    528|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  786|    528|  WebPBitstreamFeatures features;
  787|    528|  const VP8StatusCode vp8_status =
  788|    528|      WebPGetFeatures(data, chunk_data->size, &features);
  789|    528|  if (vp8_status != VP8_STATUS_OK) {
  ------------------
  |  Branch (789:7): [True: 82, False: 446]
  ------------------
  790|     82|    LOG_ERROR("VP8/VP8L bitstream error.");
  ------------------
  |  |   36|     82|  do {                                         \
  |  |   37|     82|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 82]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     82|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 82]
  |  |  ------------------
  ------------------
  791|     82|    return WEBP_INFO_BITSTREAM_ERROR;
  792|     82|  }
  793|    446|  if (!webp_info->quiet) {
  ------------------
  |  Branch (793:7): [True: 0, False: 446]
  ------------------
  794|      0|    assert(features.format >= 0 && features.format <= 2);
  795|      0|    printf(
  796|      0|        "  Width: %d\n  Height: %d\n  Alpha: %d\n  Animation: %d\n"
  797|      0|        "  Format: %s (%d)\n",
  798|      0|        features.width, features.height, features.has_alpha,
  799|      0|        features.has_animation, kFormats[features.format], features.format);
  800|      0|  }
  801|    446|  if (webp_info->is_processing_anim_frame) {
  ------------------
  |  Branch (801:7): [True: 0, False: 446]
  ------------------
  802|      0|    ++webp_info->anmf_subchunk_counts[chunk_data->id == CHUNK_VP8 ? 0 : 1];
  ------------------
  |  Branch (802:39): [True: 0, False: 0]
  ------------------
  803|      0|    if (chunk_data->id == CHUNK_VP8L && webp_info->seen_alpha_subchunk) {
  ------------------
  |  Branch (803:9): [True: 0, False: 0]
  |  Branch (803:41): [True: 0, False: 0]
  ------------------
  804|      0|      LOG_ERROR("Both VP8L and ALPH sub-chunks are present in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  805|      0|      return WEBP_INFO_PARSE_ERROR;
  806|      0|    }
  807|      0|    if (webp_info->frame_width != features.width ||
  ------------------
  |  Branch (807:9): [True: 0, False: 0]
  ------------------
  808|      0|        webp_info->frame_height != features.height) {
  ------------------
  |  Branch (808:9): [True: 0, False: 0]
  ------------------
  809|      0|      LOG_ERROR("Frame size in VP8/VP8L sub-chunk differs from ANMF header.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  810|      0|      return WEBP_INFO_PARSE_ERROR;
  811|      0|    }
  812|      0|    if (webp_info->seen_image_subchunk) {
  ------------------
  |  Branch (812:9): [True: 0, False: 0]
  ------------------
  813|      0|      LOG_ERROR("Consecutive VP8/VP8L sub-chunks in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  814|      0|      return WEBP_INFO_PARSE_ERROR;
  815|      0|    }
  816|      0|    webp_info->seen_image_subchunk = 1;
  817|    446|  } else {
  818|    446|    if (webp_info->chunk_counts[CHUNK_VP8] ||
  ------------------
  |  Branch (818:9): [True: 0, False: 446]
  ------------------
  819|    446|        webp_info->chunk_counts[CHUNK_VP8L]) {
  ------------------
  |  Branch (819:9): [True: 0, False: 446]
  ------------------
  820|      0|      LOG_ERROR("Multiple VP8/VP8L chunks detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  821|      0|      return WEBP_INFO_PARSE_ERROR;
  822|      0|    }
  823|    446|    if (chunk_data->id == CHUNK_VP8L && webp_info->chunk_counts[CHUNK_ALPHA]) {
  ------------------
  |  Branch (823:9): [True: 90, False: 356]
  |  Branch (823:41): [True: 0, False: 90]
  ------------------
  824|      0|      LOG_WARN("Both VP8L and ALPH chunks are detected.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  825|      0|    }
  826|    446|    if (webp_info->chunk_counts[CHUNK_ANIM] ||
  ------------------
  |  Branch (826:9): [True: 0, False: 446]
  ------------------
  827|    446|        webp_info->chunk_counts[CHUNK_ANMF]) {
  ------------------
  |  Branch (827:9): [True: 0, False: 446]
  ------------------
  828|      0|      LOG_ERROR("VP8/VP8L chunk and ANIM/ANMF chunk are both detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  829|      0|      return WEBP_INFO_PARSE_ERROR;
  830|      0|    }
  831|    446|    if (webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (831:9): [True: 0, False: 446]
  ------------------
  832|      0|      if (webp_info->canvas_width != features.width ||
  ------------------
  |  Branch (832:11): [True: 0, False: 0]
  ------------------
  833|      0|          webp_info->canvas_height != features.height) {
  ------------------
  |  Branch (833:11): [True: 0, False: 0]
  ------------------
  834|      0|        LOG_ERROR("Image size in VP8/VP8L chunk differs from VP8X chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  835|      0|        return WEBP_INFO_PARSE_ERROR;
  836|      0|      }
  837|    446|    } else {
  838|    446|      webp_info->canvas_width = features.width;
  839|    446|      webp_info->canvas_height = features.height;
  840|    446|      if (webp_info->canvas_width < 1 || webp_info->canvas_height < 1 ||
  ------------------
  |  Branch (840:11): [True: 0, False: 446]
  |  Branch (840:42): [True: 0, False: 446]
  ------------------
  841|    446|          webp_info->canvas_width > MAX_CANVAS_SIZE ||
  ------------------
  |  |   81|    892|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (841:11): [True: 0, False: 446]
  ------------------
  842|    446|          webp_info->canvas_height > MAX_CANVAS_SIZE ||
  ------------------
  |  |   81|    892|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (842:11): [True: 0, False: 446]
  ------------------
  843|    446|          (uint64_t)webp_info->canvas_width * webp_info->canvas_height >
  ------------------
  |  Branch (843:11): [True: 0, False: 446]
  ------------------
  844|    446|              MAX_IMAGE_AREA) {
  ------------------
  |  |   82|    446|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  845|      0|        LOG_WARN("Invalid parameters in VP8/VP8L chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  846|      0|      }
  847|    446|    }
  848|    446|    ++webp_info->chunk_counts[chunk_data->id];
  849|    446|  }
  850|    446|  ++webp_info->num_frames;
  851|    446|  webp_info->has_alpha |= features.has_alpha;
  852|    446|  if (webp_info->parse_bitstream) {
  ------------------
  |  Branch (852:7): [True: 446, False: 0]
  ------------------
  853|    446|    const int is_lossy = (chunk_data->id == CHUNK_VP8);
  854|    446|    const WebPInfoStatus status =
  855|    446|        is_lossy ? ParseLossyHeader(chunk_data, webp_info)
  ------------------
  |  Branch (855:9): [True: 356, False: 90]
  ------------------
  856|    446|                 : ParseLosslessHeader(chunk_data, webp_info);
  857|    446|    if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (857:9): [True: 293, False: 153]
  ------------------
  858|    446|  }
  859|    153|  return WEBP_INFO_OK;
  860|    446|}
webp_info_fuzzer.cc:_ZL16ParseLossyHeaderPK9ChunkDataPK8WebPInfo:
  325|    356|                                       const WebPInfo* const webp_info) {
  326|    356|  const uint8_t* data = chunk_data->payload;
  327|    356|  size_t data_size = chunk_data->size - CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    356|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  328|    356|  const uint32_t bits = (uint32_t)data[0] | (data[1] << 8) | (data[2] << 16);
  329|    356|  const int key_frame = !(bits & 1);
  330|    356|  const int profile = (bits >> 1) & 7;
  331|    356|  const int display = (bits >> 4) & 1;
  332|    356|  const uint32_t partition0_length = (bits >> 5);
  333|    356|  WebPInfoStatus status = WEBP_INFO_OK;
  334|    356|  uint64_t bit_position = 0;
  335|    356|  uint64_t* const bit_pos = &bit_position;
  336|    356|  int colorspace, clamp_type;
  337|    356|  printf("  Parsing lossy bitstream...\n");
  338|       |  // Calling WebPGetFeatures() in ProcessImageChunk() should ensure this.
  339|    356|  assert(chunk_data->size >= CHUNK_HEADER_SIZE + 10);
  340|    356|  if (profile > 3) {
  ------------------
  |  Branch (340:7): [True: 0, False: 356]
  ------------------
  341|      0|    LOG_ERROR("Unknown profile.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  342|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  343|      0|  }
  344|    356|  if (!display) {
  ------------------
  |  Branch (344:7): [True: 0, False: 356]
  ------------------
  345|      0|    LOG_ERROR("Frame is not displayable.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  346|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  347|      0|  }
  348|    356|  data += 3;
  349|    356|  data_size -= 3;
  350|    356|  printf(
  351|    356|      "  Key frame:        %s\n"
  352|    356|      "  Profile:          %d\n"
  353|    356|      "  Display:          Yes\n"
  354|    356|      "  Part. 0 length:   %d\n",
  355|    356|      key_frame ? "Yes" : "No", profile, partition0_length);
  ------------------
  |  Branch (355:7): [True: 356, False: 0]
  ------------------
  356|    356|  if (key_frame) {
  ------------------
  |  Branch (356:7): [True: 356, False: 0]
  ------------------
  357|    356|    if (!(data[0] == 0x9d && data[1] == 0x01 && data[2] == 0x2a)) {
  ------------------
  |  Branch (357:11): [True: 356, False: 0]
  |  Branch (357:30): [True: 356, False: 0]
  |  Branch (357:49): [True: 356, False: 0]
  ------------------
  358|      0|      LOG_ERROR("Invalid lossy bitstream signature.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  359|      0|      return WEBP_INFO_BITSTREAM_ERROR;
  360|      0|    }
  361|    356|    printf(
  362|    356|        "  Width:            %d\n"
  363|    356|        "  X scale:          %d\n"
  364|    356|        "  Height:           %d\n"
  365|    356|        "  Y scale:          %d\n",
  366|    356|        ((data[4] << 8) | data[3]) & 0x3fff, data[4] >> 6,
  367|    356|        ((data[6] << 8) | data[5]) & 0x3fff, data[6] >> 6);
  368|    356|    data += 7;
  369|    356|    data_size -= 7;
  370|    356|  } else {
  371|      0|    LOG_ERROR("Non-keyframe detected in lossy bitstream.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  372|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  373|      0|  }
  374|    356|  if (partition0_length >= data_size) {
  ------------------
  |  Branch (374:7): [True: 18, False: 338]
  ------------------
  375|     18|    LOG_ERROR("Bad partition length.");
  ------------------
  |  |   36|     18|  do {                                         \
  |  |   37|     18|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 18]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
  376|     18|    return WEBP_INFO_BITSTREAM_ERROR;
  377|     18|  }
  378|    338|  GET_BITS(colorspace, 1);
  ------------------
  |  |  229|    338|  do {                                                 \
  |  |  230|    338|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 338]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    338|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 338]
  |  |  ------------------
  ------------------
  379|    338|  GET_BITS(clamp_type, 1);
  ------------------
  |  |  229|    338|  do {                                                 \
  |  |  230|    338|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 338]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    338|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 338]
  |  |  ------------------
  ------------------
  380|    338|  printf("  Color space:      %d\n", colorspace);
  381|    338|  printf("  Clamp type:       %d\n", clamp_type);
  382|    338|  status = ParseLossySegmentHeader(webp_info, data, data_size, bit_pos);
  383|    338|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (383:7): [True: 27, False: 311]
  ------------------
  384|    311|  status = ParseLossyFilterHeader(webp_info, data, data_size, bit_pos);
  385|    311|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (385:7): [True: 30, False: 281]
  ------------------
  386|    281|  {  // Partition number and size.
  387|    281|    const uint8_t* part_size = data + partition0_length;
  388|    281|    int num_parts, i;
  389|    281|    size_t part_data_size;
  390|    281|    GET_BITS(num_parts, 2);
  ------------------
  |  |  229|    281|  do {                                                 \
  |  |  230|    281|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 6, False: 275]
  |  |  ------------------
  |  |  231|      6|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      6|  do {                                         \
  |  |  |  |   37|      6|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 6]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      6|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      6|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      6|    }                                                  \
  |  |  234|    281|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 275]
  |  |  ------------------
  ------------------
  391|    275|    num_parts = 1 << num_parts;
  392|    275|    if ((int)(data_size - partition0_length) < (num_parts - 1) * 3) {
  ------------------
  |  Branch (392:9): [True: 11, False: 264]
  ------------------
  393|     11|      LOG_ERROR("Truncated lossy bitstream.");
  ------------------
  |  |   36|     11|  do {                                         \
  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     11|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  ------------------
  ------------------
  394|     11|      return WEBP_INFO_TRUNCATED_DATA;
  395|     11|    }
  396|    264|    part_data_size = data_size - partition0_length - (num_parts - 1) * 3;
  397|    264|    printf("  Total partitions: %d\n", num_parts);
  398|    338|    for (i = 1; i < num_parts; ++i) {
  ------------------
  |  Branch (398:17): [True: 190, False: 148]
  ------------------
  399|    190|      const size_t psize =
  400|    190|          part_size[0] | (part_size[1] << 8) | (part_size[2] << 16);
  401|    190|      if (psize > part_data_size) {
  ------------------
  |  Branch (401:11): [True: 116, False: 74]
  ------------------
  402|    116|        LOG_ERROR("Truncated partition.");
  ------------------
  |  |   36|    116|  do {                                         \
  |  |   37|    116|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 116]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|    116|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 116]
  |  |  ------------------
  ------------------
  403|    116|        return WEBP_INFO_TRUNCATED_DATA;
  404|    116|      }
  405|     74|      printf("  Part. %d length:   %d\n", i, (int)psize);
  406|     74|      part_data_size -= psize;
  407|     74|      part_size += 3;
  408|     74|    }
  409|    264|  }
  410|       |  // Quantizer.
  411|    148|  {
  412|    148|    int base_q, bit;
  413|    148|    int dq_y1_dc = 0, dq_y2_dc = 0, dq_y2_ac = 0, dq_uv_dc = 0, dq_uv_ac = 0;
  414|    148|    GET_BITS(base_q, 7);
  ------------------
  |  |  229|    148|  do {                                                 \
  |  |  230|    148|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 9, False: 139]
  |  |  ------------------
  |  |  231|      9|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      9|  do {                                         \
  |  |  |  |   37|      9|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 9]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      9|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 9]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      9|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      9|    }                                                  \
  |  |  234|    148|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 139]
  |  |  ------------------
  ------------------
  415|    139|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    139|  do {                                                 \
  |  |  230|    139|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 137]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|    139|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 137]
  |  |  ------------------
  ------------------
  416|    137|    if (bit) GET_SIGNED_BITS(dq_y1_dc, 4);
  ------------------
  |  |  237|     60|  do {                                                       \
  |  |  238|     60|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 2, False: 58]
  |  |  ------------------
  |  |  239|      2|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      2|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      2|    }                                                        \
  |  |  242|     60|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 58]
  |  |  ------------------
  ------------------
  |  Branch (416:9): [True: 60, False: 77]
  ------------------
  417|    135|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    135|  do {                                                 \
  |  |  230|    135|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 3, False: 132]
  |  |  ------------------
  |  |  231|      3|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      3|  do {                                         \
  |  |  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      3|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      3|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      3|    }                                                  \
  |  |  234|    135|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 132]
  |  |  ------------------
  ------------------
  418|    132|    if (bit) GET_SIGNED_BITS(dq_y2_dc, 4);
  ------------------
  |  |  237|     72|  do {                                                       \
  |  |  238|     72|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 1, False: 71]
  |  |  ------------------
  |  |  239|      1|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      1|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      1|    }                                                        \
  |  |  242|     72|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 71]
  |  |  ------------------
  ------------------
  |  Branch (418:9): [True: 72, False: 60]
  ------------------
  419|    131|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    131|  do {                                                 \
  |  |  230|    131|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 3, False: 128]
  |  |  ------------------
  |  |  231|      3|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      3|  do {                                         \
  |  |  |  |   37|      3|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      3|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      3|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      3|    }                                                  \
  |  |  234|    131|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 128]
  |  |  ------------------
  ------------------
  420|    128|    if (bit) GET_SIGNED_BITS(dq_y2_ac, 4);
  ------------------
  |  |  237|     61|  do {                                                       \
  |  |  238|     61|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 2, False: 59]
  |  |  ------------------
  |  |  239|      2|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      2|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      2|    }                                                        \
  |  |  242|     61|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 59]
  |  |  ------------------
  ------------------
  |  Branch (420:9): [True: 61, False: 67]
  ------------------
  421|    126|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    126|  do {                                                 \
  |  |  230|    126|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 125]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    126|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 125]
  |  |  ------------------
  ------------------
  422|    125|    if (bit) GET_SIGNED_BITS(dq_uv_dc, 4);
  ------------------
  |  |  237|     60|  do {                                                       \
  |  |  238|     60|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 1, False: 59]
  |  |  ------------------
  |  |  239|      1|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      1|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      1|    }                                                        \
  |  |  242|     60|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 59]
  |  |  ------------------
  ------------------
  |  Branch (422:9): [True: 60, False: 65]
  ------------------
  423|    124|    GET_BITS(bit, 1);
  ------------------
  |  |  229|    124|  do {                                                 \
  |  |  230|    124|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 5, False: 119]
  |  |  ------------------
  |  |  231|      5|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      5|  do {                                         \
  |  |  |  |   37|      5|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 5]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      5|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      5|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      5|    }                                                  \
  |  |  234|    124|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 119]
  |  |  ------------------
  ------------------
  424|    119|    if (bit) GET_SIGNED_BITS(dq_uv_ac, 4);
  ------------------
  |  |  237|     67|  do {                                                       \
  |  |  238|     67|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 4, False: 63]
  |  |  ------------------
  |  |  239|      4|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      4|  do {                                         \
  |  |  |  |   37|      4|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      4|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      4|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      4|    }                                                        \
  |  |  242|     67|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 63]
  |  |  ------------------
  ------------------
  |  Branch (424:9): [True: 67, False: 52]
  ------------------
  425|    115|    printf("  Base Q:           %d\n", base_q);
  426|    115|    printf("  DQ Y1 DC:         %d\n", dq_y1_dc);
  427|    115|    printf("  DQ Y2 DC:         %d\n", dq_y2_dc);
  428|    115|    printf("  DQ Y2 AC:         %d\n", dq_y2_ac);
  429|    115|    printf("  DQ UV DC:         %d\n", dq_uv_dc);
  430|    115|    printf("  DQ UV AC:         %d\n", dq_uv_ac);
  431|    115|  }
  432|    115|  if ((*bit_pos >> 3) >= partition0_length) {
  ------------------
  |  Branch (432:7): [True: 44, False: 71]
  ------------------
  433|     44|    LOG_ERROR("Truncated lossy bitstream.");
  ------------------
  |  |   36|     44|  do {                                         \
  |  |   37|     44|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 44]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     44|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 44]
  |  |  ------------------
  ------------------
  434|     44|    return WEBP_INFO_TRUNCATED_DATA;
  435|     44|  }
  436|     71|  return WEBP_INFO_OK;
  437|    115|}
webp_info_fuzzer.cc:_ZL7GetBitsPKhmmPiPm:
  205|  12.0k|                   int* val, uint64_t* const bit_pos) {
  206|  12.0k|  *val = 0;
  207|  42.7k|  while (nb-- > 0) {
  ------------------
  |  Branch (207:10): [True: 30.7k, False: 11.9k]
  ------------------
  208|  30.7k|    const uint64_t p = (*bit_pos)++;
  209|  30.7k|    if ((p >> 3) >= data_size) {
  ------------------
  |  Branch (209:9): [True: 96, False: 30.6k]
  ------------------
  210|     96|      return 0;
  211|  30.6k|    } else {
  212|  30.6k|      const int bit = !!(data[p >> 3] & (128 >> ((p & 7))));
  213|  30.6k|      *val = (*val << 1) | bit;
  214|  30.6k|    }
  215|  30.7k|  }
  216|  11.9k|  return 1;
  217|  12.0k|}
webp_info_fuzzer.cc:_ZL23ParseLossySegmentHeaderPK8WebPInfoPKhmPm:
  247|    338|                                              uint64_t* const bit_pos) {
  248|    338|  int use_segment;
  249|    338|  GET_BITS(use_segment, 1);
  ------------------
  |  |  229|    338|  do {                                                 \
  |  |  230|    338|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 338]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    338|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 338]
  |  |  ------------------
  ------------------
  250|    338|  printf("  Use segment:      %d\n", use_segment);
  251|    338|  if (use_segment) {
  ------------------
  |  Branch (251:7): [True: 273, False: 65]
  ------------------
  252|    273|    int update_map, update_data;
  253|    273|    GET_BITS(update_map, 1);
  ------------------
  |  |  229|    273|  do {                                                 \
  |  |  230|    273|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 273]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    273|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 273]
  |  |  ------------------
  ------------------
  254|    273|    GET_BITS(update_data, 1);
  ------------------
  |  |  229|    273|  do {                                                 \
  |  |  230|    273|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 273]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    273|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 273]
  |  |  ------------------
  ------------------
  255|    273|    printf(
  256|    273|        "  Update map:       %d\n"
  257|    273|        "  Update data:      %d\n",
  258|    273|        update_map, update_data);
  259|    273|    if (update_data) {
  ------------------
  |  Branch (259:9): [True: 225, False: 48]
  ------------------
  260|    225|      int i, a_delta;
  261|    225|      int quantizer[4] = {0, 0, 0, 0};
  262|    225|      int filter_strength[4] = {0, 0, 0, 0};
  263|    225|      GET_BITS(a_delta, 1);
  ------------------
  |  |  229|    225|  do {                                                 \
  |  |  230|    225|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 225]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    225|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 225]
  |  |  ------------------
  ------------------
  264|    225|      printf("  Absolute delta:   %d\n", a_delta);
  265|  1.11k|      for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (265:19): [True: 896, False: 220]
  ------------------
  266|    896|        int bit;
  267|    896|        GET_BITS(bit, 1);
  ------------------
  |  |  229|    896|  do {                                                 \
  |  |  230|    896|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 895]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    896|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 895]
  |  |  ------------------
  ------------------
  268|    895|        if (bit) GET_SIGNED_BITS(quantizer[i], 7);
  ------------------
  |  |  237|    678|  do {                                                       \
  |  |  238|    678|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 4, False: 674]
  |  |  ------------------
  |  |  239|      4|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|      4|  do {                                         \
  |  |  |  |   37|      4|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      4|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      4|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|      4|    }                                                        \
  |  |  242|    678|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 674]
  |  |  ------------------
  ------------------
  |  Branch (268:13): [True: 678, False: 217]
  ------------------
  269|    895|      }
  270|  1.07k|      for (i = 0; i < 4; ++i) {
  ------------------
  |  Branch (270:19): [True: 866, False: 210]
  ------------------
  271|    866|        int bit;
  272|    866|        GET_BITS(bit, 1);
  ------------------
  |  |  229|    866|  do {                                                 \
  |  |  230|    866|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 0, False: 866]
  |  |  ------------------
  |  |  231|      0|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      0|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      0|    }                                                  \
  |  |  234|    866|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 866]
  |  |  ------------------
  ------------------
  273|    866|        if (bit) GET_SIGNED_BITS(filter_strength[i], 6);
  ------------------
  |  |  237|    653|  do {                                                       \
  |  |  238|    653|    if (!GetSignedBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (238:9): [True: 10, False: 643]
  |  |  ------------------
  |  |  239|     10|      LOG_ERROR("Truncated lossy bitstream.");               \
  |  |  ------------------
  |  |  |  |   36|     10|  do {                                         \
  |  |  |  |   37|     10|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 10]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|     10|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|     10|      return WEBP_INFO_TRUNCATED_DATA;                       \
  |  |  241|     10|    }                                                        \
  |  |  242|    653|  } while (0)
  |  |  ------------------
  |  |  |  Branch (242:12): [Folded, False: 643]
  |  |  ------------------
  ------------------
  |  Branch (273:13): [True: 653, False: 213]
  ------------------
  274|    866|      }
  275|    210|      printf("  Quantizer:        %d %d %d %d\n", quantizer[0], quantizer[1],
  276|    210|             quantizer[2], quantizer[3]);
  277|    210|      printf("  Filter strength:  %d %d %d %d\n", filter_strength[0],
  278|    210|             filter_strength[1], filter_strength[2], filter_strength[3]);
  279|    210|    }
  280|    258|    if (update_map) {
  ------------------
  |  Branch (280:9): [True: 199, False: 59]
  ------------------
  281|    199|      int i;
  282|    199|      int prob_segment[3] = {255, 255, 255};
  283|    770|      for (i = 0; i < 3; ++i) {
  ------------------
  |  Branch (283:19): [True: 583, False: 187]
  ------------------
  284|    583|        int bit;
  285|    583|        GET_BITS(bit, 1);
  ------------------
  |  |  229|    583|  do {                                                 \
  |  |  230|    583|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 582]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    583|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 582]
  |  |  ------------------
  ------------------
  286|    582|        if (bit) GET_BITS(prob_segment[i], 8);
  ------------------
  |  |  229|    391|  do {                                                 \
  |  |  230|    391|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 11, False: 380]
  |  |  ------------------
  |  |  231|     11|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|     11|  do {                                         \
  |  |  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|     11|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|     11|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|     11|    }                                                  \
  |  |  234|    391|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 380]
  |  |  ------------------
  ------------------
  |  Branch (286:13): [True: 391, False: 191]
  ------------------
  287|    582|      }
  288|    187|      printf("  Prob segment:     %d %d %d\n", prob_segment[0], prob_segment[1],
  289|    187|             prob_segment[2]);
  290|    187|    }
  291|    258|  }
  292|    311|  return WEBP_INFO_OK;
  293|    338|}
webp_info_fuzzer.cc:_ZL22ParseLossyFilterHeaderPK8WebPInfoPKhmPm:
  298|    311|                                             uint64_t* const bit_pos) {
  299|    311|  int simple_filter, level, sharpness, use_lf_delta;
  300|    311|  GET_BITS(simple_filter, 1);
  ------------------
  |  |  229|    311|  do {                                                 \
  |  |  230|    311|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 309]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|    311|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 309]
  |  |  ------------------
  ------------------
  301|    309|  GET_BITS(level, 6);
  ------------------
  |  |  229|    309|  do {                                                 \
  |  |  230|    309|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 8, False: 301]
  |  |  ------------------
  |  |  231|      8|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      8|  do {                                         \
  |  |  |  |   37|      8|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 8]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      8|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      8|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      8|    }                                                  \
  |  |  234|    309|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 301]
  |  |  ------------------
  ------------------
  302|    301|  GET_BITS(sharpness, 3);
  ------------------
  |  |  229|    301|  do {                                                 \
  |  |  230|    301|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 5, False: 296]
  |  |  ------------------
  |  |  231|      5|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      5|  do {                                         \
  |  |  |  |   37|      5|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 5]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      5|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      5|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      5|    }                                                  \
  |  |  234|    301|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 296]
  |  |  ------------------
  ------------------
  303|    296|  GET_BITS(use_lf_delta, 1);
  ------------------
  |  |  229|    296|  do {                                                 \
  |  |  230|    296|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 295]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    296|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 295]
  |  |  ------------------
  ------------------
  304|    295|  printf("  Simple filter:    %d\n", simple_filter);
  305|    295|  printf("  Level:            %d\n", level);
  306|    295|  printf("  Sharpness:        %d\n", sharpness);
  307|    295|  printf("  Use lf delta:     %d\n", use_lf_delta);
  308|    295|  if (use_lf_delta) {
  ------------------
  |  Branch (308:7): [True: 188, False: 107]
  ------------------
  309|    188|    int update;
  310|    188|    GET_BITS(update, 1);
  ------------------
  |  |  229|    188|  do {                                                 \
  |  |  230|    188|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 1, False: 187]
  |  |  ------------------
  |  |  231|      1|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      1|  do {                                         \
  |  |  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      1|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      1|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      1|    }                                                  \
  |  |  234|    188|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 187]
  |  |  ------------------
  ------------------
  311|    187|    printf("  Update lf delta:  %d\n", update);
  312|    187|    if (update) {
  ------------------
  |  Branch (312:9): [True: 137, False: 50]
  ------------------
  313|    137|      int i;
  314|  1.17k|      for (i = 0; i < 4 + 4; ++i) {
  ------------------
  |  Branch (314:19): [True: 1.04k, False: 124]
  ------------------
  315|  1.04k|        int temp;
  316|  1.04k|        GET_BITS(temp, 1);
  ------------------
  |  |  229|  1.04k|  do {                                                 \
  |  |  230|  1.04k|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 2, False: 1.04k]
  |  |  ------------------
  |  |  231|      2|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|      2|  do {                                         \
  |  |  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      2|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|      2|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|      2|    }                                                  \
  |  |  234|  1.04k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 1.04k]
  |  |  ------------------
  ------------------
  317|  1.04k|        if (temp) GET_BITS(temp, 7);
  ------------------
  |  |  229|    749|  do {                                                 \
  |  |  230|    749|    if (!GetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (230:9): [True: 11, False: 738]
  |  |  ------------------
  |  |  231|     11|      LOG_ERROR("Truncated lossy bitstream.");         \
  |  |  ------------------
  |  |  |  |   36|     11|  do {                                         \
  |  |  |  |   37|     11|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 11]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|     11|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 11]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  232|     11|      return WEBP_INFO_TRUNCATED_DATA;                 \
  |  |  233|     11|    }                                                  \
  |  |  234|    749|  } while (0)
  |  |  ------------------
  |  |  |  Branch (234:12): [Folded, False: 738]
  |  |  ------------------
  ------------------
  |  Branch (317:13): [True: 749, False: 296]
  ------------------
  318|  1.04k|      }
  319|    137|    }
  320|    187|  }
  321|    281|  return WEBP_INFO_OK;
  322|    295|}
webp_info_fuzzer.cc:_ZL13GetSignedBitsPKhmmPiPm:
  220|  1.65k|                         int* val, uint64_t* const bit_pos) {
  221|  1.65k|  int sign;
  222|  1.65k|  if (!GetBits(data, data_size, nb, val, bit_pos)) return 0;
  ------------------
  |  Branch (222:7): [True: 20, False: 1.63k]
  ------------------
  223|  1.63k|  if (!GetBits(data, data_size, 1, &sign, bit_pos)) return 0;
  ------------------
  |  Branch (223:7): [True: 4, False: 1.62k]
  ------------------
  224|  1.62k|  if (sign) *val = -(*val);
  ------------------
  |  Branch (224:7): [True: 876, False: 751]
  ------------------
  225|  1.62k|  return 1;
  226|  1.63k|}
webp_info_fuzzer.cc:_ZL19ParseLosslessHeaderPK9ChunkDataP8WebPInfo:
  498|     90|                                          WebPInfo* const webp_info) {
  499|     90|  const uint8_t* data = chunk_data->payload;
  500|     90|  size_t data_size = chunk_data->size - CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|     90|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  501|     90|  uint64_t bit_position = 0;
  502|     90|  uint64_t* const bit_pos = &bit_position;
  503|     90|  WebPInfoStatus status;
  504|     90|  printf("  Parsing lossless bitstream...\n");
  505|     90|  if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|     90|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (505:7): [True: 0, False: 90]
  ------------------
  506|      0|    LOG_ERROR("Truncated lossless bitstream.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  507|      0|    return WEBP_INFO_TRUNCATED_DATA;
  508|      0|  }
  509|     90|  if (data[0] != VP8L_MAGIC_BYTE) {
  ------------------
  |  |   28|     90|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (509:7): [True: 0, False: 90]
  ------------------
  510|      0|    LOG_ERROR("Invalid lossless bitstream signature.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  511|      0|    return WEBP_INFO_BITSTREAM_ERROR;
  512|      0|  }
  513|     90|  data += 1;
  514|     90|  data_size -= 1;
  515|     90|  {
  516|     90|    int width, height, has_alpha, version;
  517|     90|    LL_GET_BITS(width, 14);
  ------------------
  |  |  460|     90|  do {                                                   \
  |  |  461|     90|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 90]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     90|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 90]
  |  |  ------------------
  ------------------
  518|     90|    LL_GET_BITS(height, 14);
  ------------------
  |  |  460|     90|  do {                                                   \
  |  |  461|     90|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 90]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     90|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 90]
  |  |  ------------------
  ------------------
  519|     90|    LL_GET_BITS(has_alpha, 1);
  ------------------
  |  |  460|     90|  do {                                                   \
  |  |  461|     90|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 90]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     90|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 90]
  |  |  ------------------
  ------------------
  520|     90|    LL_GET_BITS(version, 3);
  ------------------
  |  |  460|     90|  do {                                                   \
  |  |  461|     90|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 90]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     90|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 90]
  |  |  ------------------
  ------------------
  521|     90|    width += 1;
  522|     90|    height += 1;
  523|     90|    printf("  Width:            %d\n", width);
  524|     90|    printf("  Height:           %d\n", height);
  525|     90|    printf("  Alpha:            %d\n", has_alpha);
  526|     90|    printf("  Version:          %d\n", version);
  527|     90|  }
  528|      0|  status = ParseLosslessTransform(webp_info, data, data_size, bit_pos);
  529|     90|  if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (529:7): [True: 8, False: 82]
  ------------------
  530|     82|  return WEBP_INFO_OK;
  531|     90|}
webp_info_fuzzer.cc:_ZL9LLGetBitsPKhmmPiPm:
  443|    595|                     int* val, uint64_t* const bit_pos) {
  444|    595|  uint32_t i = 0;
  445|    595|  *val = 0;
  446|  4.05k|  while (i < nb) {
  ------------------
  |  Branch (446:10): [True: 3.46k, False: 587]
  ------------------
  447|  3.46k|    const uint64_t p = (*bit_pos)++;
  448|  3.46k|    if ((p >> 3) >= data_size) {
  ------------------
  |  Branch (448:9): [True: 8, False: 3.45k]
  ------------------
  449|      8|      return 0;
  450|  3.45k|    } else {
  451|  3.45k|      const int bit = !!(data[p >> 3] & (1 << ((p & 7))));
  452|  3.45k|      *val = *val | (bit << i);
  453|  3.45k|      ++i;
  454|  3.45k|    }
  455|  3.46k|  }
  456|    587|  return 1;
  457|    595|}
webp_info_fuzzer.cc:_ZL22ParseLosslessTransformP8WebPInfoPKhmPm:
  470|     90|                                             uint64_t* const bit_pos) {
  471|     90|  int use_transform, block_size, n_colors;
  472|     90|  LL_GET_BITS(use_transform, 1);
  ------------------
  |  |  460|     90|  do {                                                   \
  |  |  461|     90|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 90]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     90|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 90]
  |  |  ------------------
  ------------------
  473|     90|  printf("  Use transform:    %s\n", use_transform ? "Yes" : "No");
  ------------------
  |  Branch (473:38): [True: 77, False: 13]
  ------------------
  474|     90|  if (use_transform) {
  ------------------
  |  Branch (474:7): [True: 77, False: 13]
  ------------------
  475|     77|    int type;
  476|     77|    LL_GET_BITS(type, 2);
  ------------------
  |  |  460|     77|  do {                                                   \
  |  |  461|     77|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 77]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     77|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 77]
  |  |  ------------------
  ------------------
  477|     77|    printf("  1st transform:    %s (%d)\n", kLosslessTransforms[type], type);
  478|     77|    switch (type) {
  479|     18|      case PREDICTOR_TRANSFORM:
  ------------------
  |  Branch (479:7): [True: 18, False: 59]
  ------------------
  480|     37|      case CROSS_COLOR_TRANSFORM:
  ------------------
  |  Branch (480:7): [True: 19, False: 58]
  ------------------
  481|     37|        LL_GET_BITS(block_size, 3);
  ------------------
  |  |  460|     37|  do {                                                   \
  |  |  461|     37|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 0, False: 37]
  |  |  ------------------
  |  |  462|      0|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      0|  do {                                         \
  |  |  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      0|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      0|    }                                                    \
  |  |  465|     37|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 37]
  |  |  ------------------
  ------------------
  482|     37|        block_size = 1 << (block_size + 2);
  483|     37|        printf("  Tran. block size: %d\n", block_size);
  484|     37|        break;
  485|     31|      case COLOR_INDEXING_TRANSFORM:
  ------------------
  |  Branch (485:7): [True: 31, False: 46]
  ------------------
  486|     31|        LL_GET_BITS(n_colors, 8);
  ------------------
  |  |  460|     31|  do {                                                   \
  |  |  461|     31|    if (!LLGetBits(data, data_size, n, &(v), bit_pos)) { \
  |  |  ------------------
  |  |  |  Branch (461:9): [True: 8, False: 23]
  |  |  ------------------
  |  |  462|      8|      LOG_ERROR("Truncated lossless bitstream.");        \
  |  |  ------------------
  |  |  |  |   36|      8|  do {                                         \
  |  |  |  |   37|      8|    if (webp_info->show_diagnosis) {           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (37:9): [True: 0, False: 8]
  |  |  |  |  ------------------
  |  |  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |  |  |   39|      0|    }                                          \
  |  |  |  |   40|      8|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (40:12): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  463|      8|      return WEBP_INFO_TRUNCATED_DATA;                   \
  |  |  464|      8|    }                                                    \
  |  |  465|     31|  } while (0)
  |  |  ------------------
  |  |  |  Branch (465:12): [Folded, False: 23]
  |  |  ------------------
  ------------------
  487|     23|        n_colors += 1;
  488|     23|        printf("  No. of colors:    %d\n", n_colors);
  489|     23|        break;
  490|      9|      default:
  ------------------
  |  Branch (490:7): [True: 9, False: 68]
  ------------------
  491|      9|        break;
  492|     77|    }
  493|     77|  }
  494|     82|  return WEBP_INFO_OK;
  495|     90|}
webp_info_fuzzer.cc:_ZL16ProcessVP8XChunkPK9ChunkDataP8WebPInfo:
  663|    100|                                       WebPInfo* const webp_info) {
  664|    100|  const uint8_t* data = chunk_data->payload;
  665|    100|  if (webp_info->chunk_counts[CHUNK_VP8] ||
  ------------------
  |  Branch (665:7): [True: 0, False: 100]
  ------------------
  666|    100|      webp_info->chunk_counts[CHUNK_VP8L] ||
  ------------------
  |  Branch (666:7): [True: 0, False: 100]
  ------------------
  667|    100|      webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (667:7): [True: 0, False: 100]
  ------------------
  668|      0|    LOG_ERROR("Already seen a VP8/VP8L/VP8X chunk when parsing VP8X chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  669|      0|    return WEBP_INFO_PARSE_ERROR;
  670|      0|  }
  671|    100|  if (chunk_data->size != VP8X_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   79|    100|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
                if (chunk_data->size != VP8X_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|    100|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (671:7): [True: 13, False: 87]
  ------------------
  672|     13|    LOG_ERROR("Corrupted VP8X chunk.");
  ------------------
  |  |   36|     13|  do {                                         \
  |  |   37|     13|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 13]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|     13|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 13]
  |  |  ------------------
  ------------------
  673|     13|    return WEBP_INFO_PARSE_ERROR;
  674|     13|  }
  675|     87|  ++webp_info->chunk_counts[CHUNK_VP8X];
  676|     87|  webp_info->feature_flags = *data;
  677|     87|  data += 4;
  678|     87|  webp_info->canvas_width = 1 + ReadLE24(&data);
  679|     87|  webp_info->canvas_height = 1 + ReadLE24(&data);
  680|     87|  if (!webp_info->quiet) {
  ------------------
  |  Branch (680:7): [True: 0, False: 87]
  ------------------
  681|      0|    printf("  ICCP: %d\n  Alpha: %d\n  EXIF: %d\n  XMP: %d\n  Animation: %d\n",
  682|      0|           (webp_info->feature_flags & ICCP_FLAG) != 0,
  683|      0|           (webp_info->feature_flags & ALPHA_FLAG) != 0,
  684|      0|           (webp_info->feature_flags & EXIF_FLAG) != 0,
  685|      0|           (webp_info->feature_flags & XMP_FLAG) != 0,
  686|      0|           (webp_info->feature_flags & ANIMATION_FLAG) != 0);
  687|      0|    printf("  Canvas size %d x %d\n", webp_info->canvas_width,
  688|      0|           webp_info->canvas_height);
  689|      0|  }
  690|     87|  if (webp_info->canvas_width > MAX_CANVAS_SIZE) {
  ------------------
  |  |   81|     87|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (690:7): [True: 0, False: 87]
  ------------------
  691|      0|    LOG_WARN("Canvas width is out of range in VP8X chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  692|      0|  }
  693|     87|  if (webp_info->canvas_height > MAX_CANVAS_SIZE) {
  ------------------
  |  |   81|     87|#define MAX_CANVAS_SIZE (1 << 24)      // 24-bit max for VP8X width/height.
  ------------------
  |  Branch (693:7): [True: 0, False: 87]
  ------------------
  694|      0|    LOG_WARN("Canvas height is out of range in VP8X chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  695|      0|  }
  696|     87|  if ((uint64_t)webp_info->canvas_width * webp_info->canvas_height >
  ------------------
  |  Branch (696:7): [True: 41, False: 46]
  ------------------
  697|     87|      MAX_IMAGE_AREA) {
  ------------------
  |  |   82|     87|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  698|       |    LOG_WARN("Canvas area is out of range in VP8X chunk.");
  ------------------
  |  |   43|     41|  do {                                           \
  |  |   44|     41|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 41]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|     41|    ++webp_info->num_warnings;                   \
  |  |   48|     41|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 41]
  |  |  ------------------
  ------------------
  699|     41|  }
  700|     87|  return WEBP_INFO_OK;
  701|    100|}
webp_info_fuzzer.cc:_ZL8ReadLE24PPKh:
  152|    174|static int ReadLE24(const uint8_t** data) {
  153|    174|  const int val = GetLE24(*data);
  154|    174|  *data += 3;
  155|    174|  return val;
  156|    174|}
webp_info_fuzzer.cc:_ZL7GetLE24PKh:
  138|    174|static int GetLE24(const uint8_t* const data) {
  139|    174|  return GetLE16(data) | (data[2] << 16);
  140|    174|}
webp_info_fuzzer.cc:_ZL16ProcessALPHChunkPK9ChunkDataP8WebPInfo:
  863|      1|                                       WebPInfo* const webp_info) {
  864|      1|  if (webp_info->is_processing_anim_frame) {
  ------------------
  |  Branch (864:7): [True: 0, False: 1]
  ------------------
  865|      0|    ++webp_info->anmf_subchunk_counts[2];
  866|      0|    if (webp_info->seen_alpha_subchunk) {
  ------------------
  |  Branch (866:9): [True: 0, False: 0]
  ------------------
  867|      0|      LOG_ERROR("Consecutive ALPH sub-chunks in an ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  868|      0|      return WEBP_INFO_PARSE_ERROR;
  869|      0|    }
  870|      0|    webp_info->seen_alpha_subchunk = 1;
  871|       |
  872|      0|    if (webp_info->seen_image_subchunk) {
  ------------------
  |  Branch (872:9): [True: 0, False: 0]
  ------------------
  873|      0|      LOG_ERROR(
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  874|      0|          "ALPHA sub-chunk detected after VP8 sub-chunk "
  875|      0|          "in an ANMF chunk.");
  876|      0|      return WEBP_INFO_PARSE_ERROR;
  877|      0|    }
  878|      1|  } else {
  879|      1|    if (webp_info->chunk_counts[CHUNK_ANIM] ||
  ------------------
  |  Branch (879:9): [True: 0, False: 1]
  ------------------
  880|      1|        webp_info->chunk_counts[CHUNK_ANMF]) {
  ------------------
  |  Branch (880:9): [True: 0, False: 1]
  ------------------
  881|      0|      LOG_ERROR("ALPHA chunk and ANIM/ANMF chunk are both detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  882|      0|      return WEBP_INFO_PARSE_ERROR;
  883|      0|    }
  884|      1|    if (!webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (884:9): [True: 1, False: 0]
  ------------------
  885|      1|      LOG_ERROR("ALPHA chunk detected before VP8X chunk.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  886|      1|      return WEBP_INFO_PARSE_ERROR;
  887|      1|    }
  888|      0|    if (webp_info->chunk_counts[CHUNK_VP8]) {
  ------------------
  |  Branch (888:9): [True: 0, False: 0]
  ------------------
  889|      0|      LOG_ERROR("ALPHA chunk detected after VP8 chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  890|      0|      return WEBP_INFO_PARSE_ERROR;
  891|      0|    }
  892|      0|    if (webp_info->chunk_counts[CHUNK_ALPHA]) {
  ------------------
  |  Branch (892:9): [True: 0, False: 0]
  ------------------
  893|      0|      LOG_ERROR("Multiple ALPHA chunks detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  894|      0|      return WEBP_INFO_PARSE_ERROR;
  895|      0|    }
  896|      0|    ++webp_info->chunk_counts[CHUNK_ALPHA];
  897|      0|  }
  898|      0|  webp_info->has_alpha = 1;
  899|      0|  if (webp_info->parse_bitstream) {
  ------------------
  |  Branch (899:7): [True: 0, False: 0]
  ------------------
  900|      0|    const WebPInfoStatus status = ParseAlphaHeader(chunk_data, webp_info);
  901|      0|    if (status != WEBP_INFO_OK) return status;
  ------------------
  |  Branch (901:9): [True: 0, False: 0]
  ------------------
  902|      0|  }
  903|      0|  return WEBP_INFO_OK;
  904|      0|}
webp_info_fuzzer.cc:_ZL16ProcessANIMChunkPK9ChunkDataP8WebPInfo:
  704|      1|                                       WebPInfo* const webp_info) {
  705|      1|  const uint8_t* data = chunk_data->payload;
  706|      1|  if (!webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (706:7): [True: 1, False: 0]
  ------------------
  707|      1|    LOG_ERROR("ANIM chunk detected before VP8X chunk.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  708|      1|    return WEBP_INFO_PARSE_ERROR;
  709|      1|  }
  710|      0|  if (chunk_data->size != ANIM_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   78|      0|#define ANIM_CHUNK_SIZE 6    // Size of an ANIM chunk.
  ------------------
                if (chunk_data->size != ANIM_CHUNK_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (710:7): [True: 0, False: 0]
  ------------------
  711|      0|    LOG_ERROR("Corrupted ANIM chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  712|      0|    return WEBP_INFO_PARSE_ERROR;
  713|      0|  }
  714|      0|  webp_info->bgcolor = ReadLE32(&data);
  715|      0|  webp_info->loop_count = ReadLE16(&data);
  716|      0|  ++webp_info->chunk_counts[CHUNK_ANIM];
  717|      0|  if (!webp_info->quiet) {
  ------------------
  |  Branch (717:7): [True: 0, False: 0]
  ------------------
  718|      0|    printf("  Background color:(ARGB) %02x %02x %02x %02x\n",
  719|      0|           (webp_info->bgcolor >> 24) & 0xff, (webp_info->bgcolor >> 16) & 0xff,
  720|      0|           (webp_info->bgcolor >> 8) & 0xff, webp_info->bgcolor & 0xff);
  721|      0|    printf("  Loop count      : %d\n", webp_info->loop_count);
  722|      0|  }
  723|      0|  if (webp_info->loop_count > MAX_LOOP_COUNT) {
  ------------------
  |  |   83|      0|#define MAX_LOOP_COUNT (1 << 16)       // maximum value for loop-count
  ------------------
  |  Branch (723:7): [True: 0, False: 0]
  ------------------
  724|       |    LOG_WARN("Loop count is out of range in ANIM chunk.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  725|      0|  }
  726|      0|  return WEBP_INFO_OK;
  727|      0|}
webp_info_fuzzer.cc:_ZL16ProcessANMFChunkPK9ChunkDataP8WebPInfo:
  730|      1|                                       WebPInfo* const webp_info) {
  731|      1|  const uint8_t* data = chunk_data->payload;
  732|      1|  int offset_x, offset_y, width, height, duration, blend, dispose, temp;
  733|      1|  if (webp_info->is_processing_anim_frame) {
  ------------------
  |  Branch (733:7): [True: 0, False: 1]
  ------------------
  734|      0|    LOG_ERROR("ANMF chunk detected within another ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  735|      0|    return WEBP_INFO_PARSE_ERROR;
  736|      0|  }
  737|      1|  if (!webp_info->chunk_counts[CHUNK_ANIM]) {
  ------------------
  |  Branch (737:7): [True: 1, False: 0]
  ------------------
  738|      1|    LOG_ERROR("ANMF chunk detected before ANIM chunk.");
  ------------------
  |  |   36|      1|  do {                                         \
  |  |   37|      1|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  739|      1|    return WEBP_INFO_PARSE_ERROR;
  740|      1|  }
  741|      0|  if (chunk_data->size <= CHUNK_HEADER_SIZE + ANMF_CHUNK_SIZE) {
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                if (chunk_data->size <= CHUNK_HEADER_SIZE + ANMF_CHUNK_SIZE) {
  ------------------
  |  |   77|      0|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
  |  Branch (741:7): [True: 0, False: 0]
  ------------------
  742|      0|    LOG_ERROR("Truncated data detected when parsing ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  743|      0|    return WEBP_INFO_TRUNCATED_DATA;
  744|      0|  }
  745|      0|  offset_x = 2 * ReadLE24(&data);
  746|      0|  offset_y = 2 * ReadLE24(&data);
  747|      0|  width = 1 + ReadLE24(&data);
  748|      0|  height = 1 + ReadLE24(&data);
  749|      0|  duration = ReadLE24(&data);
  750|      0|  temp = *data;
  751|      0|  dispose = temp & 1;
  752|      0|  blend = (temp >> 1) & 1;
  753|      0|  ++webp_info->chunk_counts[CHUNK_ANMF];
  754|      0|  if (!webp_info->quiet) {
  ------------------
  |  Branch (754:7): [True: 0, False: 0]
  ------------------
  755|      0|    printf(
  756|      0|        "  Offset_X: %d\n  Offset_Y: %d\n  Width: %d\n  Height: %d\n"
  757|      0|        "  Duration: %d\n  Dispose: %d\n  Blend: %d\n",
  758|      0|        offset_x, offset_y, width, height, duration, dispose, blend);
  759|      0|  }
  760|      0|  if (duration > MAX_DURATION) {
  ------------------
  |  |   84|      0|#define MAX_DURATION (1 << 24)         // maximum duration
  ------------------
  |  Branch (760:7): [True: 0, False: 0]
  ------------------
  761|      0|    LOG_ERROR("Invalid duration parameter in ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  762|      0|    return WEBP_INFO_INVALID_PARAM;
  763|      0|  }
  764|      0|  if (offset_x > MAX_POSITION_OFFSET || offset_y > MAX_POSITION_OFFSET) {
  ------------------
  |  |   85|      0|#define MAX_POSITION_OFFSET (1 << 24)  // maximum frame x/y offset
  ------------------
                if (offset_x > MAX_POSITION_OFFSET || offset_y > MAX_POSITION_OFFSET) {
  ------------------
  |  |   85|      0|#define MAX_POSITION_OFFSET (1 << 24)  // maximum frame x/y offset
  ------------------
  |  Branch (764:7): [True: 0, False: 0]
  |  Branch (764:41): [True: 0, False: 0]
  ------------------
  765|      0|    LOG_ERROR("Invalid offset parameters in ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  766|      0|    return WEBP_INFO_INVALID_PARAM;
  767|      0|  }
  768|      0|  if ((uint64_t)offset_x + width > (uint64_t)webp_info->canvas_width ||
  ------------------
  |  Branch (768:7): [True: 0, False: 0]
  ------------------
  769|      0|      (uint64_t)offset_y + height > (uint64_t)webp_info->canvas_height) {
  ------------------
  |  Branch (769:7): [True: 0, False: 0]
  ------------------
  770|      0|    LOG_ERROR("Frame exceeds canvas in ANMF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  771|      0|    return WEBP_INFO_INVALID_PARAM;
  772|      0|  }
  773|      0|  webp_info->is_processing_anim_frame = 1;
  774|      0|  webp_info->seen_alpha_subchunk = 0;
  775|      0|  webp_info->seen_image_subchunk = 0;
  776|      0|  webp_info->frame_width = width;
  777|      0|  webp_info->frame_height = height;
  778|      0|  webp_info->anim_frame_data_size =
  779|      0|      chunk_data->size - CHUNK_HEADER_SIZE - ANMF_CHUNK_SIZE;
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                    chunk_data->size - CHUNK_HEADER_SIZE - ANMF_CHUNK_SIZE;
  ------------------
  |  |   77|      0|#define ANMF_CHUNK_SIZE 16   // Size of an ANMF chunk.
  ------------------
  780|      0|  return WEBP_INFO_OK;
  781|      0|}
webp_info_fuzzer.cc:_ZL16ProcessICCPChunkPK9ChunkDataP8WebPInfo:
  907|      2|                                       WebPInfo* const webp_info) {
  908|      2|  (void)chunk_data;
  909|      2|  if (!webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (909:7): [True: 2, False: 0]
  ------------------
  910|      2|    LOG_ERROR("ICCP chunk detected before VP8X chunk.");
  ------------------
  |  |   36|      2|  do {                                         \
  |  |   37|      2|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 2]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  911|      2|    return WEBP_INFO_PARSE_ERROR;
  912|      2|  }
  913|      0|  if (webp_info->chunk_counts[CHUNK_VP8] ||
  ------------------
  |  Branch (913:7): [True: 0, False: 0]
  ------------------
  914|      0|      webp_info->chunk_counts[CHUNK_VP8L] ||
  ------------------
  |  Branch (914:7): [True: 0, False: 0]
  ------------------
  915|      0|      webp_info->chunk_counts[CHUNK_ANIM]) {
  ------------------
  |  Branch (915:7): [True: 0, False: 0]
  ------------------
  916|      0|    LOG_ERROR("ICCP chunk detected after image data.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  917|      0|    return WEBP_INFO_PARSE_ERROR;
  918|      0|  }
  919|      0|  ++webp_info->chunk_counts[CHUNK_ICCP];
  920|      0|  return WEBP_INFO_OK;
  921|      0|}
webp_info_fuzzer.cc:_ZL8ValidateP8WebPInfo:
  990|    488|static WebPInfoStatus Validate(WebPInfo* const webp_info) {
  991|    488|  if (webp_info->num_frames < 1) {
  ------------------
  |  Branch (991:7): [True: 362, False: 126]
  ------------------
  992|    362|    LOG_ERROR("No image/frame detected.");
  ------------------
  |  |   36|    362|  do {                                         \
  |  |   37|    362|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 362]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|    362|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 362]
  |  |  ------------------
  ------------------
  993|    362|    return WEBP_INFO_MISSING_DATA;
  994|    362|  }
  995|    126|  if (webp_info->chunk_counts[CHUNK_VP8X]) {
  ------------------
  |  Branch (995:7): [True: 0, False: 126]
  ------------------
  996|      0|    const int iccp = !!(webp_info->feature_flags & ICCP_FLAG);
  997|      0|    const int exif = !!(webp_info->feature_flags & EXIF_FLAG);
  998|      0|    const int xmp = !!(webp_info->feature_flags & XMP_FLAG);
  999|      0|    const int animation = !!(webp_info->feature_flags & ANIMATION_FLAG);
 1000|      0|    const int alpha = !!(webp_info->feature_flags & ALPHA_FLAG);
 1001|      0|    if (!alpha && webp_info->has_alpha) {
  ------------------
  |  Branch (1001:9): [True: 0, False: 0]
  |  Branch (1001:19): [True: 0, False: 0]
  ------------------
 1002|      0|      LOG_ERROR("Unexpected alpha data detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1003|      0|      return WEBP_INFO_PARSE_ERROR;
 1004|      0|    }
 1005|      0|    if (alpha && !webp_info->has_alpha) {
  ------------------
  |  Branch (1005:9): [True: 0, False: 0]
  |  Branch (1005:18): [True: 0, False: 0]
  ------------------
 1006|      0|      LOG_WARN("Alpha flag is set with no alpha data present.");
  ------------------
  |  |   43|      0|  do {                                           \
  |  |   44|      0|    if (webp_info->show_diagnosis) {             \
  |  |  ------------------
  |  |  |  Branch (44:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|      fprintf(stderr, "Warning: %s\n", MESSAGE); \
  |  |   46|      0|    }                                            \
  |  |   47|      0|    ++webp_info->num_warnings;                   \
  |  |   48|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (48:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1007|      0|    }
 1008|      0|    if (iccp && !webp_info->chunk_counts[CHUNK_ICCP]) {
  ------------------
  |  Branch (1008:9): [True: 0, False: 0]
  |  Branch (1008:17): [True: 0, False: 0]
  ------------------
 1009|      0|      LOG_ERROR("Missing ICCP chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1010|      0|      return WEBP_INFO_MISSING_DATA;
 1011|      0|    }
 1012|      0|    if (exif && !webp_info->chunk_counts[CHUNK_EXIF]) {
  ------------------
  |  Branch (1012:9): [True: 0, False: 0]
  |  Branch (1012:17): [True: 0, False: 0]
  ------------------
 1013|      0|      LOG_ERROR("Missing EXIF chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1014|      0|      return WEBP_INFO_MISSING_DATA;
 1015|      0|    }
 1016|      0|    if (xmp && !webp_info->chunk_counts[CHUNK_XMP]) {
  ------------------
  |  Branch (1016:9): [True: 0, False: 0]
  |  Branch (1016:16): [True: 0, False: 0]
  ------------------
 1017|      0|      LOG_ERROR("Missing XMP chunk.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1018|      0|      return WEBP_INFO_MISSING_DATA;
 1019|      0|    }
 1020|      0|    if (!iccp && webp_info->chunk_counts[CHUNK_ICCP]) {
  ------------------
  |  Branch (1020:9): [True: 0, False: 0]
  |  Branch (1020:18): [True: 0, False: 0]
  ------------------
 1021|      0|      LOG_ERROR("Unexpected ICCP chunk detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1022|      0|      return WEBP_INFO_PARSE_ERROR;
 1023|      0|    }
 1024|      0|    if (!exif && webp_info->chunk_counts[CHUNK_EXIF]) {
  ------------------
  |  Branch (1024:9): [True: 0, False: 0]
  |  Branch (1024:18): [True: 0, False: 0]
  ------------------
 1025|      0|      LOG_ERROR("Unexpected EXIF chunk detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1026|      0|      return WEBP_INFO_PARSE_ERROR;
 1027|      0|    }
 1028|      0|    if (!xmp && webp_info->chunk_counts[CHUNK_XMP]) {
  ------------------
  |  Branch (1028:9): [True: 0, False: 0]
  |  Branch (1028:17): [True: 0, False: 0]
  ------------------
 1029|      0|      LOG_ERROR("Unexpected XMP chunk detected.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1030|      0|      return WEBP_INFO_PARSE_ERROR;
 1031|      0|    }
 1032|       |    // Incomplete animation frame.
 1033|      0|    if (webp_info->is_processing_anim_frame) return WEBP_INFO_MISSING_DATA;
  ------------------
  |  Branch (1033:9): [True: 0, False: 0]
  ------------------
 1034|      0|    if (!animation && webp_info->num_frames > 1) {
  ------------------
  |  Branch (1034:9): [True: 0, False: 0]
  |  Branch (1034:23): [True: 0, False: 0]
  ------------------
 1035|      0|      LOG_ERROR("More than 1 frame detected in non-animation file.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1036|      0|      return WEBP_INFO_PARSE_ERROR;
 1037|      0|    }
 1038|      0|    if (animation && (!webp_info->chunk_counts[CHUNK_ANIM] ||
  ------------------
  |  Branch (1038:9): [True: 0, False: 0]
  |  Branch (1038:23): [True: 0, False: 0]
  ------------------
 1039|      0|                      !webp_info->chunk_counts[CHUNK_ANMF])) {
  ------------------
  |  Branch (1039:23): [True: 0, False: 0]
  ------------------
 1040|      0|      LOG_ERROR("No ANIM/ANMF chunk detected in animation file.");
  ------------------
  |  |   36|      0|  do {                                         \
  |  |   37|      0|    if (webp_info->show_diagnosis) {           \
  |  |  ------------------
  |  |  |  Branch (37:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      fprintf(stderr, "Error: %s\n", MESSAGE); \
  |  |   39|      0|    }                                          \
  |  |   40|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (40:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1041|      0|      return WEBP_INFO_PARSE_ERROR;
 1042|      0|    }
 1043|      0|  }
 1044|    126|  return WEBP_INFO_OK;
 1045|    126|}

VP8CheckSignature:
  117|    414|                      size_t data_size) {
  118|    414|  return (data_size >= 3 && data[0] == 0x9d && data[1] == 0x01 &&
  ------------------
  |  Branch (118:11): [True: 414, False: 0]
  |  Branch (118:29): [True: 399, False: 15]
  |  Branch (118:48): [True: 389, False: 10]
  ------------------
  119|    389|          data[2] == 0x2a);
  ------------------
  |  Branch (119:11): [True: 380, False: 9]
  ------------------
  120|    414|}
VP8GetInfo:
  123|    414|               size_t chunk_size, int* const width, int* const height) {
  124|    414|  if (data == NULL || data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|    414|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (124:7): [True: 0, False: 414]
  |  Branch (124:23): [True: 0, False: 414]
  ------------------
  125|      0|    return 0;  // not enough data
  126|      0|  }
  127|       |  // check signature
  128|    414|  if (!VP8CheckSignature(data + 3, data_size - 3)) {
  ------------------
  |  Branch (128:7): [True: 34, False: 380]
  ------------------
  129|     34|    return 0;  // Wrong signature.
  130|    380|  } else {
  131|    380|    const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
  132|    380|    const int key_frame = !(bits & 1);
  133|    380|    const int w = ((data[7] << 8) | data[6]) & 0x3fff;
  134|    380|    const int h = ((data[9] << 8) | data[8]) & 0x3fff;
  135|       |
  136|    380|    if (!key_frame) {  // Not a keyframe.
  ------------------
  |  Branch (136:9): [True: 1, False: 379]
  ------------------
  137|      1|      return 0;
  138|      1|    }
  139|       |
  140|    379|    if (((bits >> 1) & 7) > 3) {
  ------------------
  |  Branch (140:9): [True: 1, False: 378]
  ------------------
  141|      1|      return 0;  // unknown profile
  142|      1|    }
  143|    378|    if (!((bits >> 4) & 1)) {
  ------------------
  |  Branch (143:9): [True: 1, False: 377]
  ------------------
  144|      1|      return 0;  // first frame is invisible!
  145|      1|    }
  146|    377|    if (((bits >> 5)) >= chunk_size) {  // partition_length
  ------------------
  |  Branch (146:9): [True: 17, False: 360]
  ------------------
  147|     17|      return 0;                         // inconsistent size information.
  148|     17|    }
  149|    360|    if (w == 0 || h == 0) {
  ------------------
  |  Branch (149:9): [True: 1, False: 359]
  |  Branch (149:19): [True: 3, False: 356]
  ------------------
  150|      4|      return 0;  // We don't support both width and height to be zero.
  151|      4|    }
  152|       |
  153|    356|    if (width) {
  ------------------
  |  Branch (153:9): [True: 356, False: 0]
  ------------------
  154|    356|      *width = w;
  155|    356|    }
  156|    356|    if (height) {
  ------------------
  |  Branch (156:9): [True: 356, False: 0]
  ------------------
  157|    356|      *height = h;
  158|    356|    }
  159|       |
  160|    356|    return 1;
  161|    360|  }
  162|    414|}

VP8LCheckSignature:
  109|    106|                       size_t size) {
  110|    106|  return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   33|    212|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
                return (size >= VP8L_FRAME_HEADER_SIZE && data[0] == VP8L_MAGIC_BYTE &&
  ------------------
  |  |   28|    212|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (110:11): [True: 106, False: 0]
  |  Branch (110:45): [True: 93, False: 13]
  ------------------
  111|     93|          (data[4] >> 5) == 0);  // version
  ------------------
  |  Branch (111:11): [True: 90, False: 3]
  ------------------
  112|    106|}
VP8LGetInfo:
  126|    106|                int* const has_alpha) {
  127|    106|  if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|    106|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (127:7): [True: 0, False: 106]
  |  Branch (127:23): [True: 0, False: 106]
  ------------------
  128|      0|    return 0;  // not enough data
  129|    106|  } else if (!VP8LCheckSignature(data, data_size)) {
  ------------------
  |  Branch (129:14): [True: 16, False: 90]
  ------------------
  130|     16|    return 0;  // bad signature
  131|     90|  } else {
  132|     90|    int w, h, a;
  133|     90|    VP8LBitReader br;
  134|     90|    VP8LInitBitReader(&br, data, data_size);
  135|     90|    if (!ReadImageInfo(&br, &w, &h, &a)) {
  ------------------
  |  Branch (135:9): [True: 0, False: 90]
  ------------------
  136|      0|      return 0;
  137|      0|    }
  138|     90|    if (width != NULL) *width = w;
  ------------------
  |  Branch (138:9): [True: 90, False: 0]
  ------------------
  139|     90|    if (height != NULL) *height = h;
  ------------------
  |  Branch (139:9): [True: 90, False: 0]
  ------------------
  140|     90|    if (has_alpha != NULL) *has_alpha = a;
  ------------------
  |  Branch (140:9): [True: 90, False: 0]
  ------------------
  141|     90|    return 1;
  142|     90|  }
  143|    106|}
vp8l_dec.c:ReadImageInfo:
  115|     90|                         int* const height, int* const has_alpha) {
  116|     90|  if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0;
  ------------------
  |  |   28|     90|#define VP8L_MAGIC_BYTE 0x2f   // VP8L signature byte.
  ------------------
  |  Branch (116:7): [True: 0, False: 90]
  ------------------
  117|     90|  *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|     90|  14                         // Number of bits used to store width and height.
  ------------------
  118|     90|  *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1;
  ------------------
  |  |   30|     90|  14                         // Number of bits used to store width and height.
  ------------------
  119|     90|  *has_alpha = VP8LReadBits(br, 1);
  120|     90|  if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0;
  ------------------
  |  |   31|     90|#define VP8L_VERSION_BITS 3  // 3 bits reserved for version.
  ------------------
  |  Branch (120:7): [True: 0, False: 90]
  ------------------
  121|     90|  return !br->eos;
  122|     90|}

WebPGetFeaturesInternal:
  844|    528|                                      int version) {
  845|    528|  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  ------------------
  |  |   84|    528|#define WEBP_ABI_IS_INCOMPATIBLE(a, b) (((a) >> 8) != ((b) >> 8))
  |  |  ------------------
  |  |  |  Branch (84:40): [True: 0, False: 528]
  |  |  ------------------
  ------------------
  846|      0|    return VP8_STATUS_INVALID_PARAM;  // version mismatch
  847|      0|  }
  848|    528|  if (features == NULL) {
  ------------------
  |  Branch (848:7): [True: 0, False: 528]
  ------------------
  849|      0|    return VP8_STATUS_INVALID_PARAM;
  850|      0|  }
  851|    528|  return GetFeatures(data, data_size, features);
  852|    528|}
webp_dec.c:ParseHeadersInternal:
  298|    528|    WebPHeaderStructure* const headers) {
  299|    528|  size_t data_size = data_size_param;
  300|    528|  const uint8_t* WEBP_COUNTED_BY(data_size) data = data_param;
  301|    528|  int canvas_width = 0;
  302|    528|  int canvas_height = 0;
  303|    528|  int image_width = 0;
  304|    528|  int image_height = 0;
  305|    528|  int found_riff = 0;
  306|    528|  int found_vp8x = 0;
  307|    528|  int animation_present = 0;
  308|    528|  const int have_all_data = (headers != NULL) ? headers->have_all_data : 0;
  ------------------
  |  Branch (308:29): [True: 0, False: 528]
  ------------------
  309|       |
  310|    528|  VP8StatusCode status;
  311|    528|  WebPHeaderStructure hdrs;
  312|       |
  313|    528|  if (data == NULL || data_size < RIFF_HEADER_SIZE) {
  ------------------
  |  |   76|    528|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
  |  Branch (313:7): [True: 0, False: 528]
  |  Branch (313:23): [True: 3, False: 525]
  ------------------
  314|      3|    return VP8_STATUS_NOT_ENOUGH_DATA;
  315|      3|  }
  316|    525|  WEBP_UNSAFE_MEMSET(&hdrs, 0, sizeof(hdrs));
  ------------------
  |  |  175|    525|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  317|    525|  hdrs.data = data;
  318|    525|  hdrs.data_size = data_size;
  319|       |
  320|       |  // Skip over RIFF header.
  321|    525|  status = ParseRIFF(&data, &data_size, have_all_data, &hdrs.riff_size);
  322|    525|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (322:7): [True: 0, False: 525]
  ------------------
  323|      0|    return status;  // Wrong RIFF header / insufficient data.
  324|      0|  }
  325|    525|  found_riff = (hdrs.riff_size > 0);
  326|       |
  327|       |  // Skip over VP8X.
  328|    525|  {
  329|    525|    uint32_t flags = 0;
  330|    525|    status = ParseVP8X(&data, &data_size, &found_vp8x, &canvas_width,
  331|    525|                       &canvas_height, &flags);
  332|    525|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (332:9): [True: 0, False: 525]
  ------------------
  333|      0|      return status;  // Wrong VP8X / insufficient data.
  334|      0|    }
  335|    525|    animation_present = !!(flags & ANIMATION_FLAG);
  336|    525|    if (!found_riff && found_vp8x) {
  ------------------
  |  Branch (336:9): [True: 525, False: 0]
  |  Branch (336:24): [True: 0, False: 525]
  ------------------
  337|       |      // Note: This restriction may be removed in the future, if it becomes
  338|       |      // necessary to send VP8X chunk to the decoder.
  339|      0|      return VP8_STATUS_BITSTREAM_ERROR;
  340|      0|    }
  341|    525|    if (has_alpha != NULL) *has_alpha = !!(flags & ALPHA_FLAG);
  ------------------
  |  Branch (341:9): [True: 525, False: 0]
  ------------------
  342|    525|    if (has_animation != NULL) *has_animation = animation_present;
  ------------------
  |  Branch (342:9): [True: 525, False: 0]
  ------------------
  343|    525|    if (format != NULL) *format = 0;  // default = undefined
  ------------------
  |  Branch (343:9): [True: 525, False: 0]
  ------------------
  344|       |
  345|    525|    image_width = canvas_width;
  346|    525|    image_height = canvas_height;
  347|    525|    if (found_vp8x && animation_present && headers == NULL) {
  ------------------
  |  Branch (347:9): [True: 0, False: 525]
  |  Branch (347:23): [True: 0, False: 0]
  |  Branch (347:44): [True: 0, False: 0]
  ------------------
  348|      0|      status = VP8_STATUS_OK;
  349|      0|      goto ReturnWidthHeight;  // Just return features from VP8X header.
  350|      0|    }
  351|    525|  }
  352|       |
  353|    525|  if (data_size < TAG_SIZE) {
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (353:7): [True: 0, False: 525]
  ------------------
  354|      0|    status = VP8_STATUS_NOT_ENOUGH_DATA;
  355|      0|    goto ReturnWidthHeight;
  356|      0|  }
  357|       |
  358|       |  // Skip over optional chunks if data started with "RIFF + VP8X" or "ALPH".
  359|    525|  if ((found_riff && found_vp8x) ||
  ------------------
  |  Branch (359:8): [True: 0, False: 525]
  |  Branch (359:22): [True: 0, False: 0]
  ------------------
  360|    525|      (!found_riff && !found_vp8x && !memcmp(data, "ALPH", TAG_SIZE))) {
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (360:8): [True: 525, False: 0]
  |  Branch (360:23): [True: 525, False: 0]
  |  Branch (360:38): [True: 0, False: 525]
  ------------------
  361|      0|    size_t local_alpha_data_size = 0;
  362|      0|    const uint8_t* WEBP_COUNTED_BY(local_alpha_data_size) local_alpha_data =
  363|      0|        NULL;
  364|      0|    status = ParseOptionalChunks(&data, &data_size, hdrs.riff_size,
  365|      0|                                 &local_alpha_data, &local_alpha_data_size);
  366|      0|    if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (366:9): [True: 0, False: 0]
  ------------------
  367|      0|      goto ReturnWidthHeight;  // Invalid chunk size / insufficient data.
  368|      0|    }
  369|      0|    hdrs.alpha_data = local_alpha_data;
  370|      0|    hdrs.alpha_data_size = local_alpha_data_size;
  371|      0|  }
  372|       |
  373|       |  // Skip over VP8/VP8L header.
  374|    525|  status = ParseVP8Header(&data, &data_size, have_all_data, hdrs.riff_size,
  375|    525|                          &hdrs.compressed_size, &hdrs.is_lossless);
  376|    525|  if (status != VP8_STATUS_OK) {
  ------------------
  |  Branch (376:7): [True: 0, False: 525]
  ------------------
  377|      0|    goto ReturnWidthHeight;  // Wrong VP8/VP8L chunk-header / insufficient data.
  378|      0|  }
  379|    525|  if (hdrs.compressed_size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|    525|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (379:7): [True: 0, False: 525]
  ------------------
  380|      0|    return VP8_STATUS_BITSTREAM_ERROR;
  381|      0|  }
  382|       |
  383|    525|  if (format != NULL && !animation_present) {
  ------------------
  |  Branch (383:7): [True: 525, False: 0]
  |  Branch (383:25): [True: 525, False: 0]
  ------------------
  384|    525|    *format = hdrs.is_lossless ? 2 : 1;
  ------------------
  |  Branch (384:15): [True: 107, False: 418]
  ------------------
  385|    525|  }
  386|       |
  387|    525|  if (!hdrs.is_lossless) {
  ------------------
  |  Branch (387:7): [True: 418, False: 107]
  ------------------
  388|    418|    if (data_size < VP8_FRAME_HEADER_SIZE) {
  ------------------
  |  |   24|    418|#define VP8_FRAME_HEADER_SIZE 10  // Size of the frame header within VP8 data.
  ------------------
  |  Branch (388:9): [True: 4, False: 414]
  ------------------
  389|      4|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  390|      4|      goto ReturnWidthHeight;
  391|      4|    }
  392|       |    // Validates raw VP8 data.
  393|    414|    if (!VP8GetInfo(data, data_size, (uint32_t)hdrs.compressed_size,
  ------------------
  |  Branch (393:9): [True: 58, False: 356]
  ------------------
  394|    414|                    &image_width, &image_height)) {
  395|     58|      return VP8_STATUS_BITSTREAM_ERROR;
  396|     58|    }
  397|    414|  } else {
  398|    107|    if (data_size < VP8L_FRAME_HEADER_SIZE) {
  ------------------
  |  |   33|    107|#define VP8L_FRAME_HEADER_SIZE 5  // Size of the VP8L frame header.
  ------------------
  |  Branch (398:9): [True: 1, False: 106]
  ------------------
  399|      1|      status = VP8_STATUS_NOT_ENOUGH_DATA;
  400|      1|      goto ReturnWidthHeight;
  401|      1|    }
  402|       |    // Validates raw VP8L data.
  403|    106|    if (!VP8LGetInfo(data, data_size, &image_width, &image_height, has_alpha)) {
  ------------------
  |  Branch (403:9): [True: 16, False: 90]
  ------------------
  404|     16|      return VP8_STATUS_BITSTREAM_ERROR;
  405|     16|    }
  406|    106|  }
  407|       |  // Validates image size coherency.
  408|    446|  if (found_vp8x) {
  ------------------
  |  Branch (408:7): [True: 0, False: 446]
  ------------------
  409|      0|    if (canvas_width != image_width || canvas_height != image_height) {
  ------------------
  |  Branch (409:9): [True: 0, False: 0]
  |  Branch (409:40): [True: 0, False: 0]
  ------------------
  410|      0|      return VP8_STATUS_BITSTREAM_ERROR;
  411|      0|    }
  412|      0|  }
  413|    446|  if (headers != NULL) {
  ------------------
  |  Branch (413:7): [True: 0, False: 446]
  ------------------
  414|      0|    *headers = hdrs;
  415|      0|    headers->offset = data - headers->data;
  416|      0|    assert((uint64_t)(data - headers->data) < MAX_CHUNK_PAYLOAD);
  417|      0|    assert(headers->offset == headers->data_size - data_size);
  418|      0|  }
  419|    451|ReturnWidthHeight:
  420|    451|  if (status == VP8_STATUS_OK ||
  ------------------
  |  Branch (420:7): [True: 446, False: 5]
  ------------------
  421|    446|      (status == VP8_STATUS_NOT_ENOUGH_DATA && found_vp8x && headers == NULL)) {
  ------------------
  |  Branch (421:8): [True: 5, False: 0]
  |  Branch (421:48): [True: 0, False: 5]
  |  Branch (421:62): [True: 0, False: 0]
  ------------------
  422|    446|    if (has_alpha != NULL) {
  ------------------
  |  Branch (422:9): [True: 446, False: 0]
  ------------------
  423|       |      // If the data did not contain a VP8X/VP8L chunk the only definitive way
  424|       |      // to set this is by looking for alpha data (from an ALPH chunk).
  425|    446|      *has_alpha |= (hdrs.alpha_data != NULL);
  426|    446|    }
  427|    446|    if (width != NULL) *width = image_width;
  ------------------
  |  Branch (427:9): [True: 446, False: 0]
  ------------------
  428|    446|    if (height != NULL) *height = image_height;
  ------------------
  |  Branch (428:9): [True: 446, False: 0]
  ------------------
  429|    446|    return VP8_STATUS_OK;
  430|    446|  } else {
  431|      5|    return status;
  432|      5|  }
  433|    451|}
webp_dec.c:ParseRIFF:
   68|    525|                               size_t* WEBP_SINGLE const riff_size) {
   69|    525|  assert(data != NULL);
   70|    525|  assert(data_size != NULL);
   71|    525|  assert(riff_size != NULL);
   72|       |
   73|    525|  *riff_size = 0;  // Default: no RIFF present.
   74|    525|  if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   76|  1.05k|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
                if (*data_size >= RIFF_HEADER_SIZE && !memcmp(*data, "RIFF", TAG_SIZE)) {
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (74:7): [True: 525, False: 0]
  |  Branch (74:41): [True: 0, False: 525]
  ------------------
   75|      0|    if (memcmp(*data + 8, "WEBP", TAG_SIZE)) {
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (75:9): [True: 0, False: 0]
  ------------------
   76|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong image file signature.
   77|      0|    } else {
   78|      0|      const uint32_t size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
   79|       |      // Check that we have at least one chunk (i.e "WEBP" + "VP8?nnnn").
   80|      0|      if (size < TAG_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    if (size < TAG_SIZE + CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (80:11): [True: 0, False: 0]
  ------------------
   81|      0|        return VP8_STATUS_BITSTREAM_ERROR;
   82|      0|      }
   83|      0|      if (size > MAX_CHUNK_PAYLOAD) {
  ------------------
  |  |   89|      0|#define MAX_CHUNK_PAYLOAD (~0U - CHUNK_HEADER_SIZE - 1)
  |  |  ------------------
  |  |  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  |  |  ------------------
  ------------------
  |  Branch (83:11): [True: 0, False: 0]
  ------------------
   84|      0|        return VP8_STATUS_BITSTREAM_ERROR;
   85|      0|      }
   86|      0|      if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (86:11): [True: 0, False: 0]
  |  Branch (86:28): [True: 0, False: 0]
  ------------------
   87|      0|        return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
   88|      0|      }
   89|       |      // We have a RIFF container. Skip it.
   90|      0|      *riff_size = size;
   91|      0|      *data_size -= RIFF_HEADER_SIZE;
  ------------------
  |  |   76|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
   92|      0|      *data += RIFF_HEADER_SIZE;
  ------------------
  |  |   76|      0|#define RIFF_HEADER_SIZE 12  // Size of the RIFF header ("RIFFnnnnWEBP").
  ------------------
   93|      0|    }
   94|      0|  }
   95|    525|  return VP8_STATUS_OK;
   96|    525|}
webp_dec.c:ParseVP8X:
  111|    525|                               uint32_t* WEBP_SINGLE const flags_ptr) {
  112|    525|  const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
                const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE;
  ------------------
  |  |   79|    525|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  113|    525|  assert(data != NULL);
  114|    525|  assert(data_size != NULL);
  115|    525|  assert(found_vp8x != NULL);
  116|       |
  117|    525|  *found_vp8x = 0;
  118|       |
  119|    525|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (119:7): [True: 0, False: 525]
  ------------------
  120|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  121|      0|  }
  122|       |
  123|    525|  if (!memcmp(*data, "VP8X", TAG_SIZE)) {
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  |  Branch (123:7): [True: 0, False: 525]
  ------------------
  124|      0|    int width, height;
  125|      0|    uint32_t flags;
  126|      0|    const uint32_t chunk_size = GetLE32(*data + TAG_SIZE);
  ------------------
  |  |   73|      0|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  127|      0|    if (chunk_size != VP8X_CHUNK_SIZE) {
  ------------------
  |  |   79|      0|#define VP8X_CHUNK_SIZE 10   // Size of a VP8X chunk.
  ------------------
  |  Branch (127:9): [True: 0, False: 0]
  ------------------
  128|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Wrong chunk size.
  129|      0|    }
  130|       |
  131|       |    // Verify if enough data is available to validate the VP8X chunk.
  132|      0|    if (*data_size < vp8x_size) {
  ------------------
  |  Branch (132:9): [True: 0, False: 0]
  ------------------
  133|      0|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  134|      0|    }
  135|      0|    flags = GetLE32(*data + 8);
  136|      0|    width = 1 + GetLE24(*data + 12);
  137|      0|    height = 1 + GetLE24(*data + 15);
  138|      0|    if (width * (uint64_t)height >= MAX_IMAGE_AREA) {
  ------------------
  |  |   82|      0|#define MAX_IMAGE_AREA (1ULL << 32)    // 32-bit max for width x height.
  ------------------
  |  Branch (138:9): [True: 0, False: 0]
  ------------------
  139|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // image is too large
  140|      0|    }
  141|       |
  142|      0|    if (flags_ptr != NULL) *flags_ptr = flags;
  ------------------
  |  Branch (142:9): [True: 0, False: 0]
  ------------------
  143|      0|    if (width_ptr != NULL) *width_ptr = width;
  ------------------
  |  Branch (143:9): [True: 0, False: 0]
  ------------------
  144|      0|    if (height_ptr != NULL) *height_ptr = height;
  ------------------
  |  Branch (144:9): [True: 0, False: 0]
  ------------------
  145|       |    // Skip over VP8X header bytes.
  146|      0|    *data_size -= vp8x_size;
  147|      0|    *data += vp8x_size;
  148|      0|    *found_vp8x = 1;
  149|      0|  }
  150|    525|  return VP8_STATUS_OK;
  151|    525|}
webp_dec.c:ParseVP8Header:
  240|    525|                                    int* WEBP_SINGLE const is_lossless) {
  241|    525|  const size_t local_data_size = *data_size;
  242|    525|  const uint8_t* WEBP_COUNTED_BY(local_data_size) const data = *data_ptr;
  243|    525|  const int is_vp8 = !memcmp(data, "VP8 ", TAG_SIZE);
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  244|    525|  const int is_vp8l = !memcmp(data, "VP8L", TAG_SIZE);
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  245|    525|  const uint32_t minimal_size =
  246|    525|      TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
                    TAG_SIZE + CHUNK_HEADER_SIZE;  // "WEBP" + "VP8 nnnn" OR
  ------------------
  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  247|       |                                     // "WEBP" + "VP8Lnnnn"
  248|    525|  (void)local_data_size;
  249|    525|  assert(data != NULL);
  250|    525|  assert(data_size != NULL);
  251|    525|  assert(chunk_size != NULL);
  252|    525|  assert(is_lossless != NULL);
  253|       |
  254|    525|  if (*data_size < CHUNK_HEADER_SIZE) {
  ------------------
  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (254:7): [True: 0, False: 525]
  ------------------
  255|      0|    return VP8_STATUS_NOT_ENOUGH_DATA;  // Insufficient data.
  256|      0|  }
  257|       |
  258|    525|  if (is_vp8 || is_vp8l) {
  ------------------
  |  Branch (258:7): [True: 418, False: 107]
  |  Branch (258:17): [True: 107, False: 0]
  ------------------
  259|       |    // Bitstream contains VP8/VP8L header.
  260|    525|    const uint32_t size = GetLE32(data + TAG_SIZE);
  ------------------
  |  |   73|    525|#define TAG_SIZE 4           // Size of a chunk tag (e.g. "VP8L").
  ------------------
  261|    525|    if ((riff_size >= minimal_size) && (size > riff_size - minimal_size)) {
  ------------------
  |  Branch (261:9): [True: 0, False: 525]
  |  Branch (261:40): [True: 0, False: 0]
  ------------------
  262|      0|      return VP8_STATUS_BITSTREAM_ERROR;  // Inconsistent size information.
  263|      0|    }
  264|    525|    if (have_all_data && (size > *data_size - CHUNK_HEADER_SIZE)) {
  ------------------
  |  |   75|      0|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  |  Branch (264:9): [True: 0, False: 525]
  |  Branch (264:26): [True: 0, False: 0]
  ------------------
  265|      0|      return VP8_STATUS_NOT_ENOUGH_DATA;  // Truncated bitstream.
  266|      0|    }
  267|       |    // Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
  268|    525|    *chunk_size = size;
  269|    525|    *data_size -= CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  270|    525|    *data_ptr += CHUNK_HEADER_SIZE;
  ------------------
  |  |   75|    525|#define CHUNK_HEADER_SIZE 8  // Size of a chunk header.
  ------------------
  271|    525|    *is_lossless = is_vp8l;
  272|    525|  } else {
  273|       |    // Raw VP8/VP8L bitstream (no header).
  274|      0|    *is_lossless = VP8LCheckSignature(data, *data_size);
  275|      0|    *chunk_size = *data_size;
  276|      0|  }
  277|       |
  278|    525|  return VP8_STATUS_OK;
  279|    525|}
webp_dec.c:GetFeatures:
  734|    528|                                 WebPBitstreamFeatures* const features) {
  735|    528|  if (features == NULL || data == NULL) {
  ------------------
  |  Branch (735:7): [True: 0, False: 528]
  |  Branch (735:27): [True: 0, False: 528]
  ------------------
  736|      0|    return VP8_STATUS_INVALID_PARAM;
  737|      0|  }
  738|    528|  DefaultFeatures(features);
  739|       |
  740|       |  // Only parse enough of the data to retrieve the features.
  741|    528|  return ParseHeadersInternal(
  742|    528|      data, data_size, &features->width, &features->height,
  743|       |      &features->has_alpha, &features->has_animation, &features->format, NULL);
  744|    528|}
webp_dec.c:DefaultFeatures:
  726|    528|static void DefaultFeatures(WebPBitstreamFeatures* const features) {
  727|    528|  assert(features != NULL);
  728|    528|  WEBP_UNSAFE_MEMSET(features, 0, sizeof(*features));
  ------------------
  |  |  175|    528|#define WEBP_UNSAFE_MEMSET(dst, c, size) memset(dst, c, size)
  ------------------
  729|    528|}

VP8LInitBitReader:
  138|     90|                       size_t length) {
  139|     90|  size_t i;
  140|     90|  vp8l_val_t value = 0;
  141|     90|  assert(br != NULL);
  142|     90|  assert(start != NULL);
  143|     90|  assert(length < 0xfffffff8u);  // can't happen with a RIFF chunk.
  144|       |
  145|     90|  br->buf = start;
  146|     90|  br->len = length;
  147|     90|  br->bit_pos = 0;
  148|     90|  br->eos = 0;
  149|       |
  150|     90|  if (length > sizeof(br->val)) {
  ------------------
  |  Branch (150:7): [True: 56, False: 34]
  ------------------
  151|     56|    length = sizeof(br->val);
  152|     56|  }
  153|    746|  for (i = 0; i < length; ++i) {
  ------------------
  |  Branch (153:15): [True: 656, False: 90]
  ------------------
  154|    656|    value |= (vp8l_val_t)start[i] << (8 * i);
  155|    656|  }
  156|     90|  br->val = value;
  157|     90|  br->pos = length;
  158|     90|}
VP8LReadBits:
  205|    450|uint32_t VP8LReadBits(VP8LBitReader* const br, int n_bits) {
  206|    450|  assert(n_bits >= 0);
  207|       |  // Flag an error if end_of_stream or n_bits is more than allowed limit.
  208|    450|  if (!br->eos && n_bits <= VP8L_MAX_NUM_BIT_READ) {
  ------------------
  |  |  144|    450|#define VP8L_MAX_NUM_BIT_READ 24
  ------------------
  |  Branch (208:7): [True: 450, False: 0]
  |  Branch (208:19): [True: 450, False: 0]
  ------------------
  209|    450|    const uint32_t val = VP8LPrefetchBits(br) & kBitMask[n_bits];
  210|    450|    const int new_bits = br->bit_pos + n_bits;
  211|    450|    br->bit_pos = new_bits;
  212|    450|    ShiftBytes(br);
  213|    450|    return val;
  214|    450|  } else {
  215|      0|    VP8LSetEndOfStream(br);
  216|      0|    return 0;
  217|      0|  }
  218|    450|}
bit_reader_utils.c:ShiftBytes:
  178|    450|static void ShiftBytes(VP8LBitReader* const br) {
  179|    721|  while (br->bit_pos >= 8 && br->pos < br->len) {
  ------------------
  |  Branch (179:10): [True: 450, False: 271]
  |  Branch (179:30): [True: 271, False: 179]
  ------------------
  180|    271|    br->val >>= 8;
  181|    271|    br->val |= ((vp8l_val_t)br->buf[br->pos]) << (VP8L_LBITS - 8);
  ------------------
  |  |  146|    271|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  182|    271|    ++br->pos;
  183|    271|    br->bit_pos -= 8;
  184|    271|  }
  185|    450|  if (VP8LIsEndOfStream(br)) {
  ------------------
  |  Branch (185:7): [True: 0, False: 450]
  ------------------
  186|      0|    VP8LSetEndOfStream(br);
  187|      0|  }
  188|    450|}

bit_reader_utils.c:VP8LIsEndOfStream:
  182|    450|static WEBP_INLINE int VP8LIsEndOfStream(const VP8LBitReader* const br) {
  183|    450|  assert(br->pos <= br->len);
  184|    450|  return br->eos || ((br->pos == br->len) && (br->bit_pos > VP8L_LBITS));
  ------------------
  |  |  146|    187|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  |  Branch (184:10): [True: 0, False: 450]
  |  Branch (184:22): [True: 187, False: 263]
  |  Branch (184:46): [True: 0, False: 187]
  ------------------
  185|    450|}
bit_reader_utils.c:VP8LPrefetchBits:
  176|    450|static WEBP_INLINE uint32_t VP8LPrefetchBits(VP8LBitReader* const br) {
  177|    450|  return (uint32_t)(br->val >> (br->bit_pos & (VP8L_LBITS - 1)));
  ------------------
  |  |  146|    450|#define VP8L_LBITS 64  // Number of bits prefetched (= bit-size of vp8l_val_t).
  ------------------
  178|    450|}

webp_dec.c:GetLE32:
  107|    525|                                        data) {
  108|    525|  return GetLE16(data) | ((uint32_t)GetLE16(data + 2) << 16);
  109|    525|}
webp_dec.c:GetLE16:
   98|  1.05k|static WEBP_INLINE int GetLE16(const uint8_t* const WEBP_COUNTED_BY(2) data) {
   99|  1.05k|  return (int)(data[0] << 0) | (data[1] << 8);
  100|  1.05k|}

webp_info_fuzzer.cc:_ZL15WebPGetFeaturesPKhmP21WebPBitstreamFeatures:
  476|    528|                size_t data_size, WebPBitstreamFeatures* features) {
  477|    528|  return WebPGetFeaturesInternal(data, data_size, features,
  478|    528|                                 WEBP_DECODER_ABI_VERSION);
  ------------------
  |  |   27|    528|#define WEBP_DECODER_ABI_VERSION 0x0210  // MAJOR(8b) + MINOR(8b)
  ------------------
  479|    528|}

nalloc_init:
  109|  1.18k|void nalloc_init(const char* prog) {
  110|  1.18k|  if (nalloc_initialized) {
  ------------------
  |  Branch (110:7): [True: 1.18k, False: 1]
  ------------------
  111|  1.18k|    return;
  112|  1.18k|  }
  113|      1|  nalloc_initialized = true;
  114|      1|  char* bitmask = getenv("NALLOC_FREQ");
  115|      1|  if (bitmask) {
  ------------------
  |  Branch (115:7): [True: 0, False: 1]
  ------------------
  116|      0|    int shift = atoi(bitmask);
  117|      0|    if (shift > 0 && shift < 31) {
  ------------------
  |  Branch (117:9): [True: 0, False: 0]
  |  Branch (117:22): [True: 0, False: 0]
  ------------------
  118|      0|      nalloc_bitmask = 1 << shift;
  119|      0|      nalloc_random_bitmask = false;
  120|      0|    } else if (shift == 0) {
  ------------------
  |  Branch (120:16): [True: 0, False: 0]
  ------------------
  121|      0|      nalloc_random_bitmask = false;
  122|      0|      nalloc_bitmask = 0;
  123|      0|    }
  124|      1|  } else if (prog == NULL || strstr(prog, "nalloc") == NULL) {
  ------------------
  |  Branch (124:14): [True: 1, False: 0]
  |  Branch (124:30): [True: 0, False: 0]
  ------------------
  125|      1|    nalloc_random_bitmask = false;
  126|      1|    nalloc_bitmask = 0;
  127|      1|    return;
  128|      1|  }
  129|       |
  130|      0|  char* magic = getenv("NALLOC_MAGIC");
  131|      0|  if (magic) {
  ------------------
  |  Branch (131:7): [True: 0, False: 0]
  ------------------
  132|      0|    nalloc_magic = (uint32_t)strtol(magic, NULL, 0);
  133|      0|  }
  134|       |
  135|      0|  char* verbose = getenv("NALLOC_VERBOSE");
  136|      0|  if (verbose) {
  ------------------
  |  Branch (136:7): [True: 0, False: 0]
  ------------------
  137|      0|    nalloc_verbose = true;
  138|      0|  }
  139|      0|}
calloc:
  295|      4|void* calloc(size_t nmemb, size_t size) {
  296|      4|  if (nalloc_fail(size, "calloc")) {
  ------------------
  |  Branch (296:7): [True: 0, False: 4]
  ------------------
  297|      0|    errno = ENOMEM;
  298|      0|    return NULL;
  299|      0|  }
  300|      4|  return nalloc_calloc(nmemb, size);
  ------------------
  |  |  252|      4|#define nalloc_calloc(s, n) __libc_calloc(s, n)
  ------------------
  301|      4|}
malloc:
  303|   123k|void* malloc(size_t size) {
  304|   123k|  if (nalloc_fail(size, "malloc")) {
  ------------------
  |  Branch (304:7): [True: 0, False: 123k]
  ------------------
  305|      0|    errno = ENOMEM;
  306|      0|    return NULL;
  307|      0|  }
  308|   123k|  return nalloc_malloc(size);
  ------------------
  |  |  251|   123k|#define nalloc_malloc(s) __libc_malloc(s)
  ------------------
  309|   123k|}
realloc:
  311|      1|void* realloc(void* ptr, size_t size) {
  312|      1|  if (nalloc_fail(size, "realloc")) {
  ------------------
  |  Branch (312:7): [True: 0, False: 1]
  ------------------
  313|      0|    errno = ENOMEM;
  314|      0|    return NULL;
  315|      0|  }
  316|      1|  return nalloc_realloc(ptr, size);
  ------------------
  |  |  253|      1|#define nalloc_realloc(p, s) __libc_realloc(p, s)
  ------------------
  317|      1|}
webp_info_fuzzer.cc:_ZL11nalloc_failmPKc:
  187|   123k|static bool nalloc_fail(size_t size, const char* op) {
  188|       |  // do not fail before thread init
  189|   123k|  if (nalloc_runs == 0) {
  ------------------
  |  Branch (189:7): [True: 123k, False: 0]
  ------------------
  190|   123k|    return false;
  191|   123k|  }
  192|      0|  if (__sync_fetch_and_add(&nalloc_running, 1) != 1) {
  ------------------
  |  Branch (192:7): [True: 0, False: 0]
  ------------------
  193|       |    // do not fail allocations outside of fuzzer input
  194|       |    // and do not fail inside of this function
  195|      0|    __sync_fetch_and_sub(&nalloc_running, 1);
  196|      0|    return false;
  197|      0|  }
  198|      0|  nalloc_random_update((uint8_t)size);
  199|      0|  if (size >= 0x100) {
  ------------------
  |  Branch (199:7): [True: 0, False: 0]
  ------------------
  200|      0|    nalloc_random_update((uint8_t)(size >> 8));
  201|      0|    if (size >= 0x10000) {
  ------------------
  |  Branch (201:9): [True: 0, False: 0]
  ------------------
  202|      0|      nalloc_random_update((uint8_t)(size >> 16));
  203|       |      // bigger may already fail or oom
  204|      0|    }
  205|      0|  }
  206|      0|  if (((nalloc_random_state ^ nalloc_magic) & nalloc_bitmask) == 0) {
  ------------------
  |  Branch (206:7): [True: 0, False: 0]
  ------------------
  207|      0|    if (nalloc_backtrace_exclude(size, op)) {
  ------------------
  |  Branch (207:9): [True: 0, False: 0]
  ------------------
  208|      0|      __sync_fetch_and_sub(&nalloc_running, 1);
  209|      0|      return false;
  210|      0|    }
  211|      0|    __sync_fetch_and_sub(&nalloc_running, 1);
  212|      0|    return true;
  213|      0|  }
  214|      0|  __sync_fetch_and_sub(&nalloc_running, 1);
  215|      0|  return false;
  216|      0|}
webp_info_fuzzer.cc:_ZL12nalloc_startPKhm:
  149|  1.18k|static int nalloc_start(const uint8_t* data, size_t size) {
  150|  1.18k|  if (nalloc_random_bitmask) {
  ------------------
  |  Branch (150:7): [True: 0, False: 1.18k]
  ------------------
  151|      0|    if (nalloc_random_state & 0x10) {
  ------------------
  |  Branch (151:9): [True: 0, False: 0]
  ------------------
  152|      0|      nalloc_bitmask = 0xFFFFFFFF;
  153|      0|    } else {
  154|      0|      nalloc_bitmask = 1 << (5 + (nalloc_random_state & 0xF));
  155|      0|    }
  156|  1.18k|  } else if (nalloc_bitmask == 0) {
  ------------------
  |  Branch (156:14): [True: 1.18k, False: 0]
  ------------------
  157|       |    // nalloc disabled
  158|  1.18k|    return 0;
  159|  1.18k|  }
  160|      0|  nalloc_random_state = 0;
  161|      0|  for (size_t i = 0; i < size; i++) {
  ------------------
  |  Branch (161:22): [True: 0, False: 0]
  ------------------
  162|      0|    nalloc_random_update(data[i]);
  163|      0|  }
  164|      0|  if (__sync_fetch_and_add(&nalloc_running, 1)) {
  ------------------
  |  Branch (164:7): [True: 0, False: 0]
  ------------------
  165|      0|    __sync_fetch_and_sub(&nalloc_running, 1);
  166|      0|    return 0;
  167|      0|  }
  168|      0|  nalloc_runs++;
  169|      0|  return 1;
  170|      0|}
webp_info_fuzzer.cc:_ZL10nalloc_endv:
  173|  1.18k|static void nalloc_end() { __sync_fetch_and_sub(&nalloc_running, 1); }

_Z12WebPInfoTestNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE:
   29|  1.18k|void WebPInfoTest(std::string_view data) {
   30|  1.18k|  nalloc_init(nullptr);
   31|  1.18k|  nalloc_start(reinterpret_cast<const uint8_t*>(data.data()), data.size());
   32|  1.18k|  WebPInfo webp_info;
   33|  1.18k|  WebPInfoInit(&webp_info);
   34|  1.18k|  webp_info.quiet = 1;
   35|  1.18k|  webp_info.show_summary = 0;
   36|  1.18k|  webp_info.show_diagnosis = 0;
   37|  1.18k|  webp_info.parse_bitstream = 1;
   38|  1.18k|  WebPData webp_data = {reinterpret_cast<const uint8_t*>(data.data()),
   39|  1.18k|                        data.size()};
   40|  1.18k|  AnalyzeWebP(&webp_info, &webp_data);
   41|  1.18k|  nalloc_end();
   42|  1.18k|}